Spring IOC

Spring 是众多开源java项目中的一员，基于分层的javaEE应用一站式轻量级开源框架，主要核心是 IOC（控制反转/依赖注入）与 AOP（面向切面）两大技术，实现项目在开发过程中的轻松解耦，提高项目的开发效率。

在项目中引入 Spring 立即可以带来下面的好处降低组件之间的耦合度,实现软件各层之间的解耦。可以使用容器提供的众多服务，如：事务管理服务、消息服务等等。当我们使用容器管理事务时，开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。容器提供单例模式支持，开发人员不再需要自己编写实现代码。容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。

Spring 源码架构

Spring 总共大约有20个模块，由1300多个不同的文件构成。而这些组件被分别整合在核心容器（Core Container）、Aop（Aspect Oriented Programming）和设备支持（Instrmentation）、数据访问及集成（Data Access/Integeration）、Web、报文发送（Messaging）、测试6个模块集合中。

核心容器：Spring-beans 和 Spring-core 模块是 Spring 框架的核心模块，包含控制反转（Inversion of Control, IoC）和依赖注入（Dependency Injection, DI）,核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，工厂模式的实现。BeanFactory 使用控制反转（IOC）思想将应用程序的配置和依赖性规范与实际的应用程序代码分开。

Spring 上下文Spring Context：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

Spring-Expression 模块是统一表达式语言（unified EL）的扩展模块，可以查询、管理运行中的对象，同时也方便的可以调用对象方法、操作数组、集合等。它的语法类似于传统EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。

Spring-AOP：Spring-aop是Spring的另一个核心模块, 在Spring中，他是以JVM的动态代理技术为基础，然后设计出了一系列的Aop横切实现，比如前置通知、返回通知、异常通知等。通过其配置管理特性，Spring AOP 模块直接将面向切面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。

Spring Data Access(数据访问)：由Spring-jdbc、Spring-tx、Spring-orm、Spring-jms和Spring-oxm 5个模块组成 Spring-jdbc 模块是 Spring 提供的JDBC抽象框架的主要实现模块，用于简化 Spring JDBC。

Spring-tx 模块是SpringJDBC事务控制实现模块。使用Spring框架，它对事务做了很好的封装，通过它的Aop配置，可以灵活的配置在任何一层。

Spring-Orm 模块是ORM框架支持模块，主要集成 hibernate, Java Persistence API (JPA) 和 Java Data Objects (JDO) 用于资源管理、数据访问对象(DAO)的实现和事务策略。

Spring-Jms 模块（Java Messaging Service）能够发送和接受信息。

Spring-Oxm 模块主要提供一个抽象层以支撑OXM（OXM 是 Object-to-XML-Mapping 的缩写，它是一个O/M-mapper，将java对象映射成 XML 数据，或者将 XML 数据映射成 java 对象），例如：JAXB, Castor, XMLBeans, JiBX 和 XStream 等。

Web 模块：由Spring-web、Spring-webmvc、Spring-websocket和Spring-webmvc-portlet 4个模块组成，Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

报文发送：即Spring-messaging模块。

Spring-messaging是Spring4 新加入的一个模块，主要职责是为Spring 框架集成一些基础的报文传送应用。

单元测试：即Spring-test模块。Spring-test模块主要为测试提供支持

Spring 框架环境搭建

环境要求

JDK 版本：

JDK 1.7 及以上版本

Spring版本：

Spring 5.x版本

新建 Maven 项目

创建 Maven 的普通 Java 项目

设置项目的坐标

设置项目的 Maven 环境

设置项目的名称和存放的工作空间

调整项目环境

修改 JDK 版本

修改单元测试 JUnit 版本

<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency>

build标签中的pluginManagement标签

<build></build>

添加 Spring 框架的依赖坐标

Maven仓库：https://mvnrepository.com/

<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.4.RELEASE</version></dependency>

编写 Bean 对象

packagecom.xxxx.service;publicclassUserService{publicvoidtest(){System.out.println("Hello Spring!");}}

添加Spring 配置文件

在项目的src下创建文件夹 resources（Alt+insert）

将 resources 标记为资源目录

在 src\main\resources 目录下新建 spring.xml 文件，并拷贝官网文档提供的模板内容到 xml 中。

配置 bean 到 xml 中，把对应 bean 纳入到 Spring 容器来管理

spring.xml

xmlns 即 xml namespace xml使用的命名空间

xmlns:xsi 即xml schema instance xml 遵守的具体规范

xsi:schemaLocation 本文档xml遵守的规范官方指定

--><beanid="userService"class="com.xxxx.service.UserService"></bean></beans>

在 spring.xml 中配置 Bean 对象

<!--

id：bean对象的id，唯一标识。一般是Bean对象的名称的首字母小写

class：bean对象的类路径

--><beanid="userService"class="com.xxxx.service.UserService"></bean>

加载配置文件，获取实例化对象

packagecom.xxxx;importcom.xxxx.service.UserService;importorg.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationContext;publicclassApp{publicstaticvoidmain(String[]args){// 获取Spring上下文环境 (加载配置文件)ApplicationContext ac=newClassPathXmlApplicationContext("spring.xml");// 通过getBean方法得到Spring容器中实例化好的Bean对象（实例化Bean对象）// userService代表的是配置文件中bean标签的id属性值UserService userService=(UserService)ac.getBean("userService");// 调用方法（使用实例化对象）userService.test();}}

Spring IOC 容器 Bean 对象实例化模拟

思路:

定义Bean 工厂接口，提供获取bean方法

定义Bean工厂接口实现类，解析配置文件，实例化Bean对象

实现获取Bean方法

定义 Bean 属性对象

packagecom.xxxx.spring;/**

* bean对象

* 用来接收配置文件中bean标签的id与class属性值

*/publicclassMyBean{privateString id;// bean对象的id属性值privateString clazz;// bean对象的类路径publicMyBean(){}publicMyBean(String id,String clazz){this.id=id;this.clazz=clazz;}publicStringgetId(){returnid;}publicvoidsetId(String id){this.id=id;}publicStringgetClazz(){returnclazz;}publicvoidsetClazz(String clazz){this.clazz=clazz;}}

添加 dom4j 坐标依赖

<dependency><groupId>dom4j</groupId><artifactId>dom4j</artifactId><version>1.6.1</version></dependency><dependency><groupId>jaxen</groupId><artifactId>jaxen</artifactId><version>1.1.6</version></dependency>

准备自定义配置文件

spring.xml

<?xml version="1.0" encoding="utf-8" ?><beans><beanid="userService"class="com.xxxx.service.UserService"></bean><beanid="accountService"class="com.xxxx.service.AccountService"></bean></beans>

定义 Bean 工厂接口

packagecom.xxxx.spring;/**

* Bean 工厂接口定义

*/publicinterfaceMyFactory{// 通过id值获取对象publicObjectgetBean(String id);}

定义 Bean 接口的实现类

packagecom.xxxx.spring;importorg.dom4j.Document;importorg.dom4j.DocumentException;importorg.dom4j.Element;importorg.dom4j.XPath;importorg.dom4j.io.SAXReader;importjava.net.URL;importjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;importjava.util.Map;/**

* 模拟Spring的实现

* 1、通过构造器得到相关配置文件

* 2、通过dom4j解析xml文件，得到List 存放id和class

* 3、通过反射实例化得到对象 Class.forName(类的全路径).newInstance(); 通过Map<id,Class>存储

* 4、得到指定的实例化对象

*/publicclassMyClassPathXmlApplicationContextimplementsBeanFactory{privateMap beans=newHashMap();// 实例化后的对象放入mapprivateList<MyBean>myBeans;// 存放已读取bean 配置信息/* 1、通过构造器得到相关配置文件 */publicMyClassPathXmlApplicationContext(String fileName){/* 2、通过dom4j解析xml文件，得到List （存放id和class） */this.parseXml(fileName);/* 3、通过反射实例化得到对象Class.forName(类路径).newInstance(); 通过Map存储 */this.instanceBean();}/**

* 通过dom4j解析xml文件，得到List 存放id和class

* 1、获取解析器

* 2、得到配置文件的URL

* 3、通过解析器解析xml文件（spring.xml）

* 4、通过xpath语法，获取beans标签下的所有bean标签

* 5、通过指定语法解析文档对象，返回集合

* 6、判断集合是否为空，遍历集合

* 7、获取标签元素中的属性

* 8、得到Bean对象，将Bean对象设置到集合中

* @param fileName

*/privatevoidparseXml(String fileName){// 1、获取解析器SAXReader reader=newSAXReader();// 2、得到配置文件的URLURL url=this.getClass().getClassLoader().getResource(fileName);try{// 3、通过解析器解析xml文件（spring.xml）Document document=reader.read(url);// 4、通过xpath语法，获取beans标签下的所有bean标签XPath xPath=document.createXPath("beans/bean");// 通过指定语法解析文档对象，返回集合List<Element>list=xPath.selectNodes(document);// 判断集合是否为空，遍历集合if(list!=null&&list.size()>0){myBeans=newArrayList<>();for(Element el:list){// 获取标签元素中的属性String id=el.attributeValue("id");// id 属性值String clazz=el.attributeValue("class");// class 属性值System.out.println(el.attributeValue("id"));System.out.println(el.attributeValue("class"));// 得到Bean对象MyBean bean=newMyBean(id,clazz);// 将Bean对象设置到集合中myBeans.add(bean);}}}catch(DocumentExceptione){e.printStackTrace();}}/**

* 通过反射实例化得到对象

* Class.forName(类的全路径).newInstance();

* 通过Map<id,Class>存储

*/privatevoidinstanceBean(){// 判断bean集合是否为空，不为空遍历得到对应Bean对象if(myBeans!=null&&myBeans.size()>0){for(MyBean bean:myBeans){try{// 通过类的全路径实例化对象Object object=Class.forName(bean.getClazz()).newInstance();// 将id与实例化对象设置到map对象中beans.put(bean.getId(),object);}catch(Exceptione){e.printStackTrace();}}}}/**

* 通过key获取map中的指定value

* @param id

* @return

*/@OverridepublicObjectgetBean(String id){Object object=beans.get(id);returnobject;}}

测试自定义 IOC 容器

创建与配置文件中对应的Bean对象

UserService.java

packagecom.xxxx.service;publicclassUserService{publicvoidtest(){System.out.println("UserService Test...");}}

AccountService.java

packagecom.xxxx.service;publicclassAccountService{publicvoidtest(){System.out.println("AccountService Test...");}}

测试是否可以获取实例化的Bean对象

packagecom.xxxx;importcom.xxxx.spring.MyFactory;importcom.xxxx.spring.MyClassPathXmlApplicationContext;importcom.xxxx.service.AccountService;importcom.xxxx.service.UserService;publicclassApp{publicstaticvoidmain(String[]args){MyFactory factory=newMyClassPathXmlApplicationContext("spring.xml");// 得到实例化对象UserService userService=(UserService)factory.getBean("userService");userService.test();UserService userService2=(UserService)factory.getBean("userService");System.out.println(userService+"====="+userService2);AccountService accountService=(AccountService)factory.getBean("accountService");accountService.test();}}

Spring 容器在启动的时候读取xml配置信息，并对配置的 bean 进行实例化（这里模拟的比较简单，仅用于帮助大家理解），同时通过上下文对象提供的 getBean() 方法拿到我们配置的 bean 对象，从而实现外部容器自动化维护并创建 bean 的效果。

Spring IOC 配置文件加载

Spring 配置文件加载

spring.xml

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd"><beanid="userService"class="com.xxxx.service.UserService"></bean></beans>

根据相对路径加载资源

ApplicationContext ac=newClassPathXmlApplicationContext("spring.xml");

根据绝对路径加载资源（了解）

ApplicationContext ac=newFileSystemXmlApplicationContext("C:/IdeaWorkspace/spring01/src/main/resources/spring.xml");

Spring 多配置文件加载

Spring 框架启动时可以加载多个配置文件到环境中。对于比较复杂的项目，可能对应的配置文件有多个，项目在启动部署时会将多个配置文件同时加载进来。

service.xml

dao.xml

可变参数，传入多个文件名

// 同时加载多个资源文件ApplicationContext ac=newClassPathXmlApplicationContext("spring.xml","dao.xml");

通过总的配置文件import其他配置文件

spring.xml

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd"><importresource="service.xml"/><importresource="dao.xml"/></beans>

加载时只需加载总的配置文件即可

// 加载总的资源文件ApplicationContext ac=newClassPathXmlApplicationContext("spring.xml");

Spring IOC 容器 Bean 对象实例化

构造器实例化

注：通过默认构造器创建空构造方法必须存在否则创建失败

设置配置文件 spring.xml

获取实例化对象

ApplicationContext ac=newClassPathXmlApplicationContext("spring.xml");UserService userService=(UserService)ac.getBean("userService");userService.test();

静态工厂实例化（了解）

注：

要有该工厂类及工厂方法

工厂方法为静态的

定义静态工厂类

packagecom.xxxx.factory;importcom.xxxx.service.UserService;/**

* 定义静态工厂类

*/publicclassStaticFactory{/**

* 定义对应的静态方法，返回实例化对象

* @return

*/publicstaticUserServicecreateUserService(){returnnewUserService();}}

设置配置文件 spring.xml

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd"><beanid="userService"class="com.xxxx.factory.StaticFactory"factory-method="createUserService"></bean></beans>

获取实例化对象

ApplicationContext ac=newClassPathXmlApplicationContext("spring.xml");UserService userService=(UserService)ac.getBean("userService");userService.test();

当我们指定Spring使用静态工厂方法来创建Bean实例时，Spring将先解析配置文件，并根据配置文件指定的信息，通过反射调用静态工厂类的静态工厂方法，并将该静态工厂方法的返回值作为Bean实例，在这个过程中，Spring不再负责创建Bean实例，Bean实例是由用户提供的静态工厂方法提供的。

实例化工厂实例化（了解）

注：

工厂方法为非静态方法

需要配置工厂bean，并在业务bean中配置factory-bean，factory-method属性

定义工厂类

packagecom.xxxx.factory;importcom.xxxx.service.UserService;/**

* 定义工厂类

*/publicclassInstanceFactory{/**

* 定义方法，返回实例化对象

* @return

*/publicUserServicecreateUserService(){returnnewUserService();}}

设置配置文件 spring.xml

实例化工厂

1.定义实例化工厂bean

2.引用工厂bean 指定工厂创建方法(方法为非静态)

--><beanid="instanceFactory"class="com.xxxx.factory.InstanceFactory"></bean><beanid="userService"factory-bean="instanceFactory"factory-method="createUserService"></bean></beans>

获取实例化对象

ApplicationContext ac=newClassPathXmlApplicationContext("spring.xml");UserService userService=(UserService)ac.getBean("userService");userService.test();

Spring三种实例化Bean的方式比较

方式一：通过bean的缺省构造函数创建，当各个bean的业务逻辑相互比较独立的时候或者和外界关联较少的时候可以使用。

方式二：利用静态factory方法创建，可以统一管理各个bean的创建，如各个bean在创建之前需要相同的初始化处理，则可用这个factory方法险进行统一的处理等等。

方式三：利用实例化factory方法创建，即将factory方法也作为了业务bean来控制，1可用于集成其他框架的bean创建管理方法，2能够使bean和factory的角色互换。

开发中项目一般使用一种方式实例化bean，项目开发基本采用第一种方式，交给Spring托管，使用时直接拿来使用即可。另外两种了解

Spring IOC 注入

手动实例化与外部引入

图一：

图二：

对比发现：图二中对于 UserDao 对象的创建并没有像图一那样主动的去实例化，而是通过带参方法形式将UserDao 传入过来，从而实现 UserService 对UserDao类的依赖。

而实际创建对象的幕后对象即是交给了外部来创建。

Spring IOC 手动装配（注入）

Spring 支持的注入方式共有四种：set 注入、构造器注入、静态工厂注入、实例化工厂注入。

set方法注入

注：

属性字段需要提供set方法

四种方式，推荐使用set方法注入

业务对象 JavaBean

属性字段提供set方法

publicclassUserService{// 业务对象UserDao set注入（提供set方法）privateUserDao userDao;publicvoidsetUserDao(UserDao userDao){this.userDao=userDao;}}

配置文件的bean标签设置property标签

IOC通过property标签手动装配（注入）：

Set方法注入

name：bean对象中属性字段的名称

ref：指定bean标签的id属性值

--><beanid="userDao"class="com.xxxx.dao.UserDao"></bean><beanid="userService"class="com.xxxx.service.UserService"><propertyname="userDao"ref="userDao"/></bean></beans>

常用对象和基本类型

属性字段提供set方法

publicclassUserService{// 常用对象String set注入（提供set方法）privateString host;publicvoidsetHost(String host){this.host=host;}// 基本类型Integer set注入（提供set方法）privateInteger port;publicvoidsetPort(Integer port){this.port=port;}}

配置文件的bean标签设置property标签

IOC通过property标签手动装配（注入）：

Set方法注入

name：bean对象中属性字段的名称

value:具体的值（基本类型常用对象|日期集合）

--><beanid="userService"class="com.xxxx.service.UserService"><propertyname="host"value="127.0.0.1"/><propertyname="port"value="8080"/></bean></beans>

集合类型和属性对象

属性字段提供set方法

publicclassUserService{// List集合 set注入（提供set方法）publicList<String>list;publicvoidsetList(List<String>list){this.list=list;}// Set集合 set注入（提供set方法）privateSet<String>set;publicvoidsetSet(Set<String>set){this.set=set;}// Map set注入（提供set方法）privateMap<String,Object>map;publicvoidsetMap(Map<String,Object>map){this.map=map;}// Properties set注入（提供set方法）privateProperties properties;publicvoidsetProperties(Properties properties){this.properties=properties;}}

配置文件的bean标签设置property标签

IOC通过property标签手动装配（注入）：

Set方法注入

name：bean对象中属性字段的名称

value:具体的值（基本类型常用对象|日期集合）

--><propertyname="list"><list><value>上海</value><value>北京</value><value>杭州</value></list></property><propertyname="set"><set><value>上海SH</value><value>北京BJ</value><value>杭州HZ</value></set></property><propertyname="map"><map><entry><key><value>周杰伦</value></key><value>我是如此相信</value></entry><entry><key><value>林俊杰</value></key><value>可惜没如果</value></entry><entry><key><value>陈奕迅</value></key><value>十年</value></entry></map></property><propertyname="properties"><props><propkey="上海">东方明珠</prop><propkey="北京">天安门</prop><propkey="杭州">西湖</prop></props></property></beans>

测试代码

UserService.java

publicclassUserService{// 业务对象UserDao set注入（提供set方法）privateUserDao userDao;publicvoidsetUserDao(UserDao userDao){this.userDao=userDao;}// 常用对象String set注入（提供set方法）privateString host;publicvoidsetHost(String host){this.host=host;}// 基本类型Integer set注入（提供set方法）privateInteger port;publicvoidsetPort(Integer port){this.port=port;}// List集合 set注入（提供set方法）publicList<String>list;publicvoidsetList(List<String>list){this.list=list;}// List集合输出publicvoidprintList(){list.forEach(s->System.out.println(s));}// Set集合 set注入（提供set方法）privateSet<String>set;publicvoidsetSet(Set<String>set){this.set=set;}// Set集合输出publicvoidprintSet(){set.forEach(s->System.out.println(s));}// Map set注入（提供set方法）privateMap<String,Object>map;publicvoidsetMap(Map<String,Object>map){this.map=map;}// Map输出publicvoidprintMap(){map.forEach((k,v)->System.out.println(k+"，"+v));}// Properties set注入（提供set方法）privateProperties properties;publicvoidsetProperties(Properties properties){this.properties=properties;}// Properties输出publicvoidprintProperties(){properties.forEach((k,v)->System.out.println(k+"，"+v));}publicvoidtest(){System.out.println("UserService Test...");userDao.test();studentDao.test();System.out.println("Host："+host+"，port："+port);// List集合printList();// Set集合printSet();// MapprintMap();// PropertiesprintProperties();}}

spring.xml

IOC通过property标签手动装配（注入）：

Set方法注入

name：bean对象中属性字段的名称

ref：指定bean标签的id属性值

value:具体的值（基本类型常用对象|日期集合）

--><beanid="userDao"class="com.xxxx.dao.UserDao"></bean><beanid="userService"class="com.xxxx.service.UserService"><propertyname="userDao"ref="userDao"/><propertyname="studentDao"ref="studentDao"/><propertyname="host"value="192.168.1.109"/><propertyname="port"value="8080"/><propertyname="list"><list><value>上海</value><value>北京</value><value>杭州</value></list></property><propertyname="set"><set><value>上海SH</value><value>北京BJ</value><value>杭州HZ</value></set></property><propertyname="map"><map><entry><key><value>周杰伦</value></key><value>我是如此相信</value></entry><entry><key><value>林俊杰</value></key><value>可惜没如果</value></entry><entry><key><value>陈奕迅</value></key><value>十年</value></entry></map></property><propertyname="properties"><props><propkey="上海">东方明珠</prop><propkey="北京">天安门</prop><propkey="杭州">西湖</prop></props></property></bean></beans>

构造器注入

注：

提供带参构造器

单个Bean对象作为参数

Java 代码

publicclassUserService{privateUserDao userDao;// JavaBean 对象publicUserService(UserDao userDao){this.userDao=userDao;}publicvoidtest(){System.out.println("UserService Test...");userDao.test();}}

XML配置

IOC通过构造器注入：

通过constructor-arg标签进行注入

name：属性名称

ref：指定bean标签的id属性值

--><beanid="userDao"class="com.xxxx.dao.UserDao"></bean><beanid="userService"class="com.xxxx.service.UserService"><constructor-argname="userDao"ref="userDao"></constructor-arg></bean></beans>

多个Bean对象作为参数

Java 代码

publicclassUserService{privateUserDao userDao;// JavaBean 对象privateAccountDao accountDao// JavaBean 对象publicUserService(UserDao userDao,AccountDao accountDao){this.userDao=userDao;this.accountDao=accountDao;}publicvoidtest(){System.out.println("UserService Test...");userDao.test();accountDao.test();}}

XML配置

IOC通过构造器注入：

通过constructor-arg标签进行注入

name：属性名称

ref：指定bean标签的id属性值

--><beanid="userDao"class="com.xxxx.dao.UserDao"></bean><beanid="accountDao"class="com.xxxx.dao.AccountDao"></bean><beanid="userService"class="com.xxxx.service.UserService"><constructor-argname="userDao"ref="userDao"></constructor-arg><constructor-argname="accountDao"ref="accountDao"></constructor-arg></bean></beans>

Bean对象和常用对象作为参数

Java 代码

publicclassUserService{privateUserDao userDao;// JavaBean 对象privateAccountDao accountDao;// JavaBean 对象privateString uname;// 字符串类型publicUserService(UserDao userDao,AccountDao accountDao,String uname){this.userDao=userDao;this.accountDao=accountDao;this.uname=uname;}publicvoidtest(){System.out.println("UserService Test...");userDao.test();accountDao.test();System.out.println("uname："+uname);}}

XML配置

IOC通过构造器注入：

通过constructor-arg标签进行注入

name：属性名称

ref：指定bean标签的id属性值

value：基本类型常用对象的值

index：构造器中参数的下标，从0开始

循环依赖问题

循环问题产生的原因：

Bean通过构造器注入，之间彼此相互依赖对方导致bean无法实例化。

问题展示：

Java 代码

publicclassAccountService{privateRoleService roleService;publicAccountService(RoleService roleService){this.roleService=roleService;}publicvoidtest(){System.out.println("AccountService Test...");}}publicclassRoleService{privateAccountService accountService;publicRoleService(AccountService accountService){this.accountService=accountService;}publicvoidtest(){System.out.println("RoleService Test...");}}

XML配置

<!--

如果多个bean对象中互相注入，则会出现循环依赖的问题

可以通过set方法注入解决

--><beanid="accountService"class="com.xxxx.service.AccountService"><constructor-argname="roleService"ref="roleService"/></bean><beanid="roleService"class="com.xxxx.service.RoleService"><constructor-argname="accountService"ref="accountService"/></bean>

如何解决：将构造器注入改为set方法注入

Java代码

publicclassAccountService{privateRoleService roleService;/* public AccountService(RoleService roleService) {

this.roleService = roleService;

}*/publicvoidsetRoleService(RoleService roleService){this.roleService=roleService;}publicvoidtest(){System.out.println("AccountService Test...");}}publicclassRoleService{privateAccountService accountService;/* public RoleService(AccountService accountService) {

this.accountService = accountService;

}*/publicvoidsetAccountService(AccountService accountService){this.accountService=accountService;}publicvoidtest(){System.out.println("RoleService Test...");}}

XML配置

<!--

<constructor-arg name="roleService" ref="roleService"/>

</bean>

<constructor-arg name="accountService" ref="accountService"/>

</bean>

--><beanid="accountService"class="com.xxxx.service.AccountService"><propertyname="roleService"ref="roleService"/></bean><beanid="roleService"class="com.xxxx.service.RoleService"><propertyname="accountService"ref="accountService"/></bean>

静态工厂注入

定义静态工厂类

publicclassStaticFactory{// 定义静态方法publicstaticTypeDaocreateTypeDao(){returnnewTypeDao();}}

Java代码

publicclassTypeService{privateTypeDao typeDao;publicvoidsetTypeDao(TypeDao typeDao){this.typeDao=typeDao;}publicvoidtest(){System.out.println("TypeService Test...");}}

XML配置

在配置文件中设置bean标签，指定工厂对象并设置对应的方法

<beanid="typeService"class="com.xxxx.service.TypeService"><propertyname="typeDao"ref="typeDao"/></bean><!--

静态工厂注入：

静态工厂注入也是借助set方法注入，只是被注入的bean对象的实例化是通过静态工厂实例化的

--><beanid="typeDao"class="com.xxxx.factory.StaticFactory"factory-method="createTypeDao"></bean>

实例化工厂注入

定义工厂类

publicclassInstanceFactory{publicTypeDaocreateTypeDao(){returnnewTypeDao();}}

Java代码

publicclassTypeService{privateTypeDao typeDao;publicvoidsetTypeDao(TypeDao typeDao){this.typeDao=typeDao;}publicvoidtest(){System.out.println("TypeService Test...");}}

XML配置

声明工厂bean标签，声明bean对象，指明工厂对象和工厂方法

<beanid="typeService"class="com.xxxx.service.TypeService"><propertyname="typeDao"ref="typeDao"/></bean><!--

实例化工厂注入：

实例化工厂注入也是借助set方法注入，只是被注入的bean对象的实例化是通过实例化工厂实例化的

--><beanid="instanceFactory"class="com.xxxx.factory.InstanceFactory"></bean><beanid="typeDao"factory-bean="instanceFactory"factory-method="createTypeDao"></bean>

重点掌握set注入和构造器注入，工厂方式了解即可。实际开发中基本使用set方式注入bean。

注入方式的选择

开发项目中set方式注入首选

使用构造注入可以在构建对象的同时一并完成依赖关系的建立，对象一建立则所有的一切也就准备好了，但如果要建立的对象关系很多，使用构造器注入会在构建函数上留下一长串的参数,且不易记忆,这时使用Set注入会是个不错的选择。

使用Set注入可以有明确的名称，可以了解注入的对象会是什么，像setXXX()这样的名称会比记忆Constructor上某个参数的位置代表某个对象更好。

p名称空间的使用

spring2.5以后，为了简化setter方法属性注入，引用p名称空间的概念，可以将子元素，简化为元素属性配置。

属性字段提供 set 方法

在配置文件 spring.xml 引入 p 名称空间

xmlns:p="http://www.springframework.org/schema/p"

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd"><beanid="userDao"class="com.xxxx.dao.UserDao"></bean><!--

p:属性名:="xxx" 引入常量值

p:属性名-ref:="xxx" 引入其他Bean对象的id属性值

--><beanid="userService"class="com.xxxx.service.UserService"p:userDao-ref="userDao"p:host="127.0.0.1"/></beans>

Spring IOC 自动装配（注入）

注解方式注入 Bean

对于 bean 的注入，除了使用 xml 配置以外，可以使用注解配置。注解的配置，可以简化配置文件，提高开发的速度，使程序看上去更简洁。对于注解的解释，Spring对于注解有专门的解释器，对定义的注解进行解析，实现对应bean对象的注入。通过反射技术实现。

准备环境

修改配置文件

<beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

开启自动化注入

<context:annotation-config/><beanid="userDao"class="com.xxxx.dao.UserDao"></bean><beanid="userService"class="com.xxxx.service.UserService"></bean>

给注入的bean对象添加注解

@Resource注解

@Resource注解实现自动注入（反射）

默认根据属性字段名称查找对应的bean对象（属性字段的名称与bean标签的id属性值相等）

如果属性字段名称未找到，则会通过类型（Class类型）查找

属性可以提供set方法，也可以不提供set方法

注解可以声明在属性级别或 set方法级别

可以设置name属性，name属性值必须与bean标签的id属性值一致；如果设置了name属性值，就只会按照name属性值查找bean对象

当注入接口时，如果接口只有一个实现则正常实例化；如果接口存在多个实现，则需要使用name属性指定需要被实例化的bean对象

代码示例

默认根据属性字段名称查找对应的bean对象（属性字段的名称与bean标签的id属性值相等）

/**

* @Resource注解实现自动注入（反射）

* 默认根据属性字段名称查找对应的bean对象（属性字段的名称与bean标签的id属性值相等）

*/publicclassUserService{@ResourceprivateUserDao userDao;// 属性字段的名称与bean标签的id属性值相等publicvoidsetUserDao(UserDao userDao){this.userDao=userDao;}publicvoidtest(){// 调用UserDao的方法userDao.test();}}

如果属性字段名称未找到，则会通过类型（Class类型）查找

/**

* @Resource注解实现自动注入（反射）

* 如果属性字段名称未找到，则会通过类型（Class类型）查找

*/publicclassUserService{@ResourceprivateUserDao ud;// 当在配置文件中属性字段名（ud）未找到，则会查找对应的class（UserDao类型）publicvoidsetUd(UserDao ud){this.ud=ud;}publicvoidtest(){// 调用UserDao的方法ud.test();}}

属性可以提供set方法，也可以不提供set方法

/**

* @Resource注解实现自动注入（反射）

* 属性可以提供set方法，也可以不提供set方法

*/publicclassUserService{@ResourceprivateUserDao userDao;// 不提供set方法publicvoidtest(){// 调用UserDao的方法userDao.test();}}

注解可以声明在属性级别或 set方法级别

/**

* @Resource注解实现自动注入（反射）

* 注解可以声明在属性级别或 set方法级别

*/publicclassUserService{privateUserDao userDao;@Resource// 注解也可设置在set方法上publicvoidsetUserDao(UserDao userDao){this.userDao=userDao;}publicvoidtest(){// 调用UserDao的方法userDao.test();}}

可以设置name属性，name属性值必须与bean标签的id属性值一致；如果设置了name属性值，就只会按照name属性值查找bean对象

/**

* @Resource注解实现自动注入（反射）

* 可以设置name属性，name属性值必须与bean的id属性值一致；

* 如果设置了name属性值，就只会按照name属性值查找bean对象

*/publicclassUserService{@Resource(name="userDao")// name属性值与配置文件中bean标签的id属性值一致privateUserDao ud;publicvoidtest(){// 调用UserDao的方法ud.test();}}

当注入接口时，如果接口只有一个实现则正常实例化；如果接口存在多个实现，则需要使用name属性指定需要被实例化的bean对象

定义接口类 IUserDao.java

packagecom.xxxx.dao;/**

* 定义接口类

*/publicinterfaceIUserDao{publicvoidtest();}

定义接口实现类 UserDao01.java

packagecom.xxxx.dao;/**

* 接口实现类

*/publicclassUserDao01implementsIUserDao{@Overridepublicvoidtest(){System.out.println("UserDao01...");}}

定义接口实现类 UserDao02.java

packagecom.xxxx.dao;/**

* 接口实现类

*/publicclassUserDao02implementsIUserDao{@Overridepublicvoidtest(){System.out.println("UserDao02...");}}

XML配置文件

<context:annotation-config/><beanid="userService"class="com.xxxx.service.UserService"></bean><beanid="userDao01"class="com.xxxx.dao.UserDao01"></bean><beanid="userDao02"class="com.xxxx.dao.UserDao01"></bean>

使用注解 UserService.java

/**

* @Resource注解实现自动注入（反射）

* 当注入接口时，如果接口只有一个实现则正常实例化；如果接口存在多个实现，则需要使用name属性指定需要被实例化的bean对象

*/publicclassUserService{@Resource(name="userDao01")// name属性值与其中一个实现类的bean标签的id属性值一致privateIUserDao iUserDao;// 注入接口（接口存在多个实现）publicvoidtest(){iUserDao.test();}}

@Autowired注解

@Autowired注解实现自动化注入：

默认通过类型（Class类型）查找bean对象与属性字段的名称无关

属性可以提供set方法，也可以不提供set方法

注解可以声明在属性级别或 set方法级别

可以添加@Qualifier结合使用，通过value属性值查找bean对象（value属性值必须要设置，且值要与bean标签的id属性值对应）

默认通过类型（Class类型）查找bean对象与属性字段的名称无关

/**

* @Autowired注解实现自动化注入

* 默认通过类型（Class类型）查找bean对象与属性字段的名称无关

*/publicclassUserService{@AutowiredprivateUserDao userDao;// 默认通过类型（Class类型）查找bean对象与属性字段的名称无关publicvoidsetUserDao(UserDao userDao){this.userDao=userDao;}publicvoidtest(){// 调用UserDao的方法userDao.test();}}

属性可以提供set方法，也可以不提供set方法

/**

* @Autowired注解实现自动化注入

* 属性可以提供set方法，也可以不提供set方法

*/publicclassUserService{@AutowiredprivateUserDao userDao;// 不提供set方法publicvoidtest(){// 调用UserDao的方法userDao.test();}}

注解可以声明在属性级别或 set方法级别

/**

* @Autowired注解实现自动化注入

* 注解可以声明在属性级别或 set方法级别

*/publicclassUserService{privateUserDao userDao;@Autowired// 注解可以声明在set方法级别publicvoidsetUserDao(UserDao userDao){this.userDao=userDao;}publicvoidtest(){// 调用UserDao的方法userDao.test();}}

可以添加@Qualifier结合使用，通过value属性值查找bean对象（value属性值必须要设置，且值要与bean标签的id属性值对应）

/**

* @Autowired注解实现自动化注入

* 可以添加@Qualifier结合使用，通过value属性值查找bean对象

value属性值必须要设置，且值要与bean标签的id属性值对应

*/publicclassUserService{@Autowired@Qualifier(value="userDao")// value属性值必须要设置，且值要与bean标签的id属性值对应privateUserDao userDao;publicvoidtest(){userDao.test();}}

推荐使用**@Resource** 注解是属于J2EE的，减少了与Spring的耦合。

Spring IOC 扫描器

实际的开发中，bean的数量非常多，采用手动配置bean的方式已无法满足生产需要，Spring这时候同样提供了扫描的方式，对扫描到的bean对象统一进行管理，简化开发配置，提高开发效率。

Spring IOC 扫描器的配置

Spring IOC 扫描器

作用：bean对象统一进行管理，简化开发配置，提高开发效率

1、设置自动化扫描的范围

如果bean对象未在指定包范围，即使声明了注解，也无法实例化

2、使用指定的注解（声明在类级别） bean对象的id属性默认是类的首字母小写

Dao层：

@Repository

Service层：

@Service

Controller层：

@Controller

任意类：

@Component

注：开发过程中建议按照指定规则声明注解

设置自动化扫描范围

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"><context:component-scanbase-package="com.xxxx"/></beans>

使用特定的注解

@Repository （Dao层）

@RepositorypublicclassResourceDao{publicvoidtest(){System.out.println("ResourceDao...");}}

@Service（Service层）

@ServicepublicclassResourceService{@ResourceprivateResourceDao resourceDao;// service层注入dao层的bean对象publicvoidtest(){System.out.println("ResourceService...");resourceDao.test();}}

@Controller （Controller 层）

@ControllerpublicclassResourceController{@AutowiredprivateResourceService resourceService;// Controller层注入service层的bean对象publicvoidtest(){System.out.println("ResourceController...");resourceService.test();}}

@Component （任意层）

@ComponentpublicclassPropertyUtils{publicvoidtest(){System.out.println("PropertyUtils...");}}

Spring 模拟用户登录流程

Dao层（查询用户记录）

定义JavaBean User.java

packagecom.xxxx.po;/**

* User 用户实体类

*/publicclassUser{privateString userName;// 用户名称privateString userPwd;// 用户密码publicStringgetUserName(){returnuserName;}publicvoidsetUserName(String userName){this.userName=userName;}publicStringgetUserPwd(){returnuserPwd;}publicvoidsetUserPwd(String userPwd){this.userPwd=userPwd;}}

编写Dao层 UserDao.java

packagecom.xxxx.dao;importcom.xxxx.po.User;importorg.springframework.stereotype.Repository;@RepositorypublicclassUserDao{privatefinalString USERNAME="admin";privatefinalString USERPWD="admin";/**

* 通过用户名称查询用户对象

* @param userName

* @return

*/publicUserqueryUserByUserName(String userName){User user=null;// 判断用户名称是否正确if(!USERNAME.equals(userName)){// 如果不正确，返回nullreturnnull;}// 如果正确，将用户名称和密码设置到user对象中user=newUser();user.setUserName(USERNAME);user.setUserPwd(USERPWD);returnuser;}}

Service层（业务逻辑处理）

定义业务处理返回消息模型 MessageModel.java

packagecom.xxxx.po.vo;/**

* 定义业务处理返回消息模型

* 封装返回结果

*/publicclassMessageModel{privateInteger resultCode=1;// 结果状态码 1=成功，0=失败privateString resultMsg="操作成功！";// 结果提示信息publicIntegergetResultCode(){returnresultCode;}publicvoidsetResultCode(Integer resultCode){this.resultCode=resultCode;}publicStringgetResultMsg(){returnresultMsg;}publicvoidsetResultMsg(String resultMsg){this.resultMsg=resultMsg;}}

编写Service层 UserService.java

packagecom.xxxx.service;importcom.xxxx.dao.UserDao1;importcom.xxxx.po.User;importcom.xxxx.po.vo.MessageModel;importorg.springframework.stereotype.Service;importjavax.annotation.Resource;@ServicepublicclassUserService{@ResourceprivateUserDao userDao;/**

* 验证用户登录

* @param userName

* @param userPwd

* @return

*/publicMessageModeluserLoginCheck(String userName,String userPwd){// 定义业务处理返回消息模型MessageModel messageModel=newMessageModel();// 判断用户名称是否非空if(null==userName||"".equals(userName.trim())){messageModel.setResultCode(0);messageModel.setResultMsg("用户名不能为空！");returnmessageModel;}// 判断用户密码是否为空if(null==userPwd||"".equals(userPwd.trim())){messageModel.setResultCode(0);messageModel.setResultMsg("密码不能为空！");returnmessageModel;}// 通过用户名称查询用户对象User user=userDao.queryUserByUserName(userName);// 判断用户对象是否为空if(null==user){messageModel.setResultCode(0);messageModel.setResultMsg("该用户不存在！");returnmessageModel;}// 如果用户对象不为空，判断密码是否正确if(!user.getUserPwd().equals(userPwd)){messageModel.setResultCode(0);messageModel.setResultMsg("用户密码不正确！");returnmessageModel;}// 登录成功messageModel.setResultMsg("登录成功！");returnmessageModel;}}

Controller层（接收请求）

编写Controller层 UserController.java

packagecom.xxxx.controller;importcom.xxxx.po.vo.MessageModel;importcom.xxxx.service.UserService1;importorg.springframework.stereotype.Controller;importjavax.annotation.Resource;@ControllerpublicclassUserController{@ResourceprivateUserService userService;/**

* 用户登录

* @param userName

* @param userPwd

* @return

*/publicMessageModellogin(String userName,String userPwd){// 调用Dao层判断用户登录操作，返回结果MessageModel messageModel=userService.userLoginCheck(userName,userPwd);returnmessageModel;}}

通过 JUnit 进行测试

packagecom.xxxx;importcom.xxxx.controller.UserController;importcom.xxxx.po.vo.MessageModel;importorg.junit.Test;importorg.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationContext;publicclassTestLogin{@Testpublicvoidtest(){// 得到Spring容器上下文环境ApplicationContext ac=newClassPathXmlApplicationContext("spring.xml");// 得到UserController实例化对象UserController userController=(UserController)ac.getBean("userController");// 传入参数调用UserController的方法，返回封装类MessageModel messageModel=userController.login("admin","admin");System.out.println("状态码："+messageModel.getResultCode()+"，提示信息："+messageModel.getResultMsg());}}

Bean的作用域与生命周期

Bean的作用域

默认情况下，我们从Spring容器中拿到的对象均是单例的，对于bean的作用域类型如下：

singleton 作用域

注意: lazy-init是懒加载, 如果等于true时作用是指Spring容器启动的时候不会去实例化这个bean, 而是在程序调用时才去实例化. 默认是false即Spring容器启动时实例化.

默认情况下，被管理的bean只会IOC容器中存在一个实例，对于所有获取该Bean的操作Spring容器将只返回同一个Bean。

容器在启动的情况下就实例化所有singleton 的 bean对象，并缓存与容器中

lazy-init属性（懒加载）

如果为false，则在IOC容器启动时会实例化bean对象，默认false

如果为true，则IOC容器启动时不会实例化Bean对象，在使用bean对象时才会实例化

lazy-init设置为false有什么好处？

1）可以提前发现潜在的配置问题

2）Bean 对象存在于缓存中，使用时不用再去实例化bean，加快程序运行效率

什么对象适合作为单例对象？

一般来说对于无状态或状态不可改变的对象适合使用单例模式。（不存在会改变对象状态的成员变量）

比如：controller层、service层、dao层

什么是无状态或状态不可改变的对象？

实际上对象状态的变化往往均是由于属性值得变化而引起的，比如user类姓名属性会有变化，属性姓名的变化一般会引起user对象状态的变化。对于我们的程序来说，无状态对象没有实例变量的存在，保证了线程的安全性，service 层业务对象即是无状态对象。线程安全的。

prototype 作用域

通过scope=“prototype” 设置bean的类型，每次向Spring容器请求获取Bean都返回一个全新的Bean，相对于"singleton"来说就是不缓存Bean，每次都是一个根据Bean定义创建的全新Bean。

Web应用中的作用域

request作用域

表示每个请求需要容器创建一个全新Bean。比如提交表单的数据必须是对每次请求新建一个Bean来保持这些表单数据，请求结束释放这些数据。

session作用域

表示每个会话需要容器创建一个全新Bean。比如对于每个用户一般会有一个会话，该用户的用户信息需要存储到会话中，此时可以将该Bean作用域配置为session级别。

globalSession作用域

类似于session作用域，其用于portlet(Portlet是基于Java的Web组件，由Portlet容器管理，并由容器处理请求，生产动态内容)环境的web应用。如果在非portlet环境将视为session作用域。

配置方式和基本的作用域相同，只是必须要有web环境支持，并配置相应的容器监听器或拦截器从而能应用这些作用域，目前先熟悉概念，后续集成web时讲解具体使用，大家只需要知道有这些作用域就可以了。

Bean的生命周期

对比已经学过的servlet 生命周期（容器启动装载并实例化servlet类，初始化servlet，调用service方法，销毁servlet）。

同样对于Spring容器管理的bean也存在生命周期的概念

在Spring中，Bean的生命周期包括Bean的定义、初始化、使用和销毁4个阶段

Bean的定义

在Spring中，通常是通过配置文档的方式来定义Bean的。

在一个配置文档中，可以定义多个Bean。

Bean 的初始化

默认在IOC容器加载时，实例化对象。

Spring bean 初始化有两种方式：

**方式一：**在配置文档中通过指定 init-method 属性来完成。

publicclassRoleService{// 定义初始化时需要被调用的方法publicvoidinit(){System.out.println("RoleService init...");}}

<beanid="roleService"class="com.xxxx.service.RoleService"init-method="init"></bean>

方式二： 实现 org.springframework.beans.factory.InitializingBean 接口。

publicclassRoleServiceimplementsInitializingBean{@OverridepublicvoidafterPropertiesSet()throwsException{System.out.println("RoleService init...");}}

<beanid="roleService"class="com.xxxx.service.RoleService"></bean>

Bean对象实例化过程是在Spring容器初始化时被实例化的，但也不是不可改变的，可以通过 lazy-init=“true” 属性延迟bean对象的初始化操作，此时再调用getBean 方法时才会进行bean的初始化操作

Bean 的使用

**方式一：**使用 BeanFactory

// 得到Spring的上下文环境BeanFactory factory=newClassPathXmlApplicationContext("spring.xml");RoleService roleService=(RoleService)factory.getBean("roleService");

**方式二：**使用 ApplicationContext

// 得到Spring的上下文环境ApplicationContext ac=newClassPathXmlApplicationContext("spring.xml");RoleService roleService=(RoleService)ac.getBean("roleService");

Bean的销毁

实现销毁方式(Spring容器会维护bean对象的管理，可以指定bean对象的销毁所要执行的方法)。

**步骤一：**实现销毁方式(Spring容器会维护bean对象的管理，可以指定bean对象的销毁所要执行的方法)

<beanid="roleService"class="com.xxxx.service.RoleService"destroy-method="destroy"></bean>

**步骤二：**通过 AbstractApplicationContext 对象，调用其close方法实现bean的销毁过程

AbstractApplicationContext ctx=newClassPathXmlApplicationContext("spring.xml");ctx.close();

IOC/DI-控制反转和依赖注入

将对象实例化的创建过程转交给外部容器（IOC容器充当工厂角色）去负

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 194,390评论 5赞 459
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 81,821评论 2赞 371
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 141,632评论 0赞 319
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 52,170评论 1赞 263
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 61,033评论 4赞 355
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 46,098评论 1赞 272
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 36,511评论 3赞 381
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 35,204评论 0赞 253
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 39,479评论 1赞 290
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 34,572评论 2赞 309
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 36,341评论 1赞 326
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,213评论 3赞 312
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 37,576评论 3赞 298
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 28,893评论 0赞 17
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,171评论 1赞 250
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 41,486评论 2赞 341
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 40,676评论 2赞 335

Spring IOC

推荐阅读更多精彩内容