Spring 01

1 Spring 是什么？

Spring 是一个开源框架，Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，由 Rod Johnson在其著作 Expert One-On-One J2EE Development and Design 中阐述的部分理念和原型衍生而来。

它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE应用程序开发提供集成的框架。Spring 使用基本的 JavaBean 来完成以前只可能由 EJB 完成的事情。然而，Spring 的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何 Java 应用都可以从 Spring 中受益。Spring 的核心是控制反转（IOC）和面向切面（AOP）。简单来说，Spring 是一个分层的 轻量级开源框架。

了解IOC ，软件设计六大原则        ，低耦合

2 为什么使用Spring

1. 方便解耦，简化开发
2. Spring 就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring 管理
3. AOP 编程的支持，Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
4. 声明式事务的支持只需要通过配置就可以完成对事务的管理，
5. 而无需手动编程方便程序的测试，Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程序
6. 方便集成各种优秀框架，Spring  不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz 等）的直接支持
7. 降低 JavaEE API 的使用难度，Spring 对 JavaEE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等），都提供了封装，使这些 API 应用难度大大降低

 3 Spring环境搭建

 

3.1 创建Spring项目，并引入相关依赖

3.1.1 项目创建

通过idea创建一个maven项目

 3.1.2 引入spring的依赖

<properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <spring.version>4.2.5.RELEASE</spring.version>
    </properties>   

			<!--Spring核心基础依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--日志相关-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!--测试相关-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

3.2 添加配置文件

配置文件的名字可以任意设置,建议设置为applicationContext.xml，所以这里我们创建一个名为applicationContext.xml的配置文件

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

3.3 添加相应的模块

在项目中添加dao、model、service层代码

3.4 将bean的实例化交给Spring

<bean name="userDao" class="com.tledu.spring.dao.impl.UserDaoImpl" />
<!--name 属性名字/ref 引用的bean的名字-->
<bean id="userService" class="com.tledu.spring.service.UserService">
	<property name="userDao"  ref="userDao" /

3.5 测试类

public class UserServiceTest {

    @Test
    public void add() {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        // userService是bean的id或name
        UserService userService = (UserService) applicationContext
                .getBean("userService");
        userService.add(null);
    }
}

4 通过构造方法注入

 <bean name="userDao" class="com.tledu.spring.dao.impl.UserDaoImpl" />
    <bean id="userService" class="com.tledu.spring.service.UserService">
        <constructor-arg ref="userDao"/>
    </bean>

5 普通属性注入

<bean name="userDao" class="com.tledu.zrz.dao.impl.UserDaoImpl">
	<!-- 如果不是指向对象,直接用value设置值就行 -->
		<property name="daoId" value="82"></property>
		<property name="daoStatus" value="good"></property>
	</bean>

 scope

spring中scope是一个非常关键的概念，简单说就是对象在spring容器（IOC容器）中的生命周期，也可以理解为对象在spring容器中的创建方式。

目前，scope的取值有5种取值：

在Spring 2.0之前，有singleton和prototype两种；

在Spring 2.0之后，为支持web应用的ApplicationContext，增强另外三种：request，session和global session类型，它们只实用于web程序，通常是和XmlWebApplicationContext共同使用

6.1 singleton

此取值时表明容器中创建时只存在一个实例，所有引用此bean都是单一实例。

也就是说创建对象是单例模式,并且如果不进行设置,默认就行单例

6.2 prototype

spring容器在进行输出prototype的bean对象 时，会每次都重新生成一个新的对象给请求方，虽然这种类型的对象的实例化以及属性设置等工作都是由容器负责的，但是只要准备完毕，并且对象实例返回给请求 方之后，容器就不在拥有当前对象的引用，请求方需要自己负责当前对象后继生命周期的管理工作，包括该对象的销毁。也就是说，容器每次返回请求方该对象的一 个新的实例之后，就由这个对象“自生自灭”，最典型的体现就是spring与struts2进行整合时，要把action的scope改为 prototype。

简单来说,就是每次获取都创建一个新对象,并且这个对象的生命周期不归Spring管理

6.3 request

request，session和global session类型只适用于web程序，通常是和XmlWebApplicationContext共同使用。

<bean id ="requestPrecessor" class="...RequestPrecessor"   scope="request" />

Spring容器，即XmlWebApplicationContext 会为每个HTTP请求创建一个全新的RequestPrecessor对象，当请求结束后，该对象的生命周期即告结束，如同java web中request的生命周期。当同时有100个HTTP请求进来的时候，容器会分别针对这10个请求创建10个全新的RequestPrecessor实例，且他们相互之间互不干扰，简单来讲，request可以看做prototype的一种特例，除了场景更加具体之外，语意上差不多。

6.4 session

对于web应用来说，放到session中最普遍的就是用户的登录信息，对于这种放到session中的信息，我们可以使用如下形式的制定scope为session：

<bean id ="userPreferences" class="...UserPreferences"   scope="session" />

Spring容器会为每个独立的session创建属于自己的全新的UserPreferences实例，比request scope的bean会存活更长的时间，其他的方面没区别，如同java web中session的生命周期。

6.5 global session

<bean id ="userPreferences" class="...UserPreferences"   scope="globalsession" />

global session只有应用在基于porlet的web应用程序中才有意义，它映射到porlet的global范围的session，如果普通的servlet的web 应用中使用了这个scope，容器会把它作为普通的session的scope对待

6.6 配置scope方式

<bean name="userDao" class="com.tledu.zrz.dao.impl.UserDaoImpl">

  <!-- 如果不是指向对象,直接用value设置值就行 -->

  <property name="daoId" value="82"></property>

  <property name="daoStatus" value="good"></property>

        </bean >

        <!-- scope singleton : 单例 只创建一个,默认就是

                 prototype : 每一次getBean 都会创建一个新的实例化对象 

  request,session : 需要特殊环境支持 -->

        <bean id="userService" class="com.tledu.zrz.service.UserService"

  scope="singleton">

  <!-- 构造方法注入 -->

  <constructor-arg>

         <ref bean="userDao" />

  </constructor-arg>

</bean>

7 集合属性注入

7.1 相关类

UserDaoImpl中提供对应的变量

        private List<String> lists;

        private Set<String> sets;

        private Map<String, String> maps;

        public List<String> getLists() {

                 return lists;

        }

        public void setLists(List<String> lists) {

                 this.lists = lists;

        }

        public Set<String> getSets() {

                  return sets;

        }

        public void setSets(Set<String> sets) {

                  this.sets = sets;

        }

        public Map<String, String> getMaps() {

                  return maps;

        }

        public void setMaps(Map<String, String> maps) {

                  this.maps = maps;

        }

7.2 配置文件

<bean name="userDao" class="com.tledu.zrz.dao.impl.UserDaoImpl">

  <property name="lists" >

         <list>

         <value>1</value>

         <value>2</value>

         </list>

  </property>

  <property name="sets" >

  <!-- set不可重复,重复不添加,所以只有第一个三 -->

         <set>

         <value>3</value>

         <value>3</value>

         <value>5</value>

         <value>4</value>

         </set>

  </property>

  <property name="maps">

  <!-- mapkey不可重复,重复key不添加,value覆盖 -->

         <map>

         <entry key="1"  value="2"></entry>

         <entry key="1"  value="3"></entry>

         <entry key="2"  value="2"></entry>

         </map>

  </property>

        </bean>

        <bean id="userService" class="com.tledu.zrz.service.UserService"

  scope="singleton">

  <!-- 构造方法注入 -->

  <constructor-arg>

         <ref bean="userDao" />

  </constructor-arg>

        </bean>

 

8 自动装配

Autowire : 自动装配,两种取值

1 byName

2 byType  

8.1 byName

byName是根据setter方法名字进行匹配,如果找不到,就不赋值

<bean name="userDao" class="com.tledu.zrz.dao.impl.UserDaoImpl">
</bean>
<bean id="userService" class="com.tledu.zrz.service.UserService"  
 autowire="byName">
</bean>

8.2 byType

byType是根据setter方法的参数列表中的数据类型进行匹配,如果beans.xml中出现了多个相同类型的对象,就会报错

设置方式
<bean name="userDao" class="com.tledu.zrz.dao.impl.UserDaoImpl">
</bean>
<bean id="userService" class="com.tledu.zrz.service.UserService"  
 autowire="byType">
</bean>

注意 : 使用自动装配,需要有公共的无参构造,虽然这里就算是私有化构造方法也依然可以创建对象,但是还是提供一个公共的比较好,万一别的框架需要呢

9 生命周期和迟加载

之前servlet的生命周期

构造方法 -- init -- service -- destroy  

那么spring创建对象的生命周期呢?

Spring中是没有init、service和destroy的,但是我们可以指定某个方法在创建完对象之后执行,某个方法在最后销毁的时候执行.

9.1.1 相关类

UserService中提供对应的方法

public void init(){

  System.out.println("init--------");

        }

        public void destroy(){

  System.out.println("destroy----------");

        }

        public UserService() {

  System.out.println("service构造方法");

}

9.1.2 配置文件

<bean name="userDao" class="com.tledu.zrz.dao.impl.UserDaoImpl" >

        </bean>

        <!-- 

  init-method : 用于设置初始化的方法

  destory-method : 用于设置销毁资源的方法

  -->

        <bean id="userService" class="com.tledu.zrz.service.UserService" 

  autowire="byName"   init-method="init" destroy-method="destroy"  >

        </bean>

9.1.3 测试

@Test

public void testAdd() {

  ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(

    "beans.xml");

  // userService是bean的id或name

   UserService userService = (UserService) applicationContext

   .getBean("userService");

  // // userService.add(null);

   System.out.println(userService.getUserDao());

  // 销毁Spring容器

   applicationContext.destroy();

}

Destroy之所以会执行,是因为我们默认创建对象的时候是单例模式

这个时候对象的生命周期会和Spring容器的生命周期绑定到一起,所以当我们销毁Spring容器的时候,会把所有的对象销毁,并自动调用destroy方法

但是如果我们把scope设置为prototype的时候,对象的生命周期就不会再和Spring容器绑定,销毁Spring容器的时候也就不会再执行该对象的destroy方法

比如

<bean name="userDao" class="com.tledu.zrz.dao.impl.UserDaoImpl" >

        </bean>

        <!-- 

  init-method : 用于设置初始化的方法

  destory-method : 用于设置销毁资源的方法

  -->

        <bean id="userService" class="com.tledu.zrz.service.UserService"  scope="prototype"

  autowire="byName"   init-method="init" destroy-method="destroy"  >

</bean>

注意：scope为prototype类型时，我们容器只负责实例的创建，创建之后的生命周期由调用者负责。

9.2 迟加载

Spring容器默认是在执行

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");

进行解析的时候创建对象并调用init,

9.2.1 相关类
在UserDaoImpl和UserService中的构造方法添加输出语句进行测试
public UserDaoImpl(){
  System.out.println("Dao构造方法");
}
public UserService() {

9.2.2 配置文件
<bean name="userDao" class="com.tledu.zrz.dao.impl.UserDaoImpl" >
<bean id="userService" class="com.tledu.zrz.service.UserService"  scope="prototype"
  	autowire="byName"   init-method="init" destroy-method="destroy" lazy-init="true"  >
</bean>
2.1.2.3 测试
@Test
	public void testAdd() {
  ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(
    "beans.xml");
}
结果
 
通过结果可以看出,UserService的对象没有创建,那么什么时候创建呢?
  UserService userService = (UserService) applicationContext.getBean("userService");
当调用getBean()的时候 创建
或者是使用到这个对象的时候,比如我们获取userService对象,但是需要将userDao对象注入到userService中,那么这时候就算没有通过getBean(“userDao”) 而是通过getBean(“userService”)  也会创建userDao对象,因为在UserService中用到userDao了
 
为了使用方便,Spring还提出了default-lazy-init="true"
比如我们通过xml创建了10个对象,这10个对象都需要迟加载,那么每个bean标签中都设置lazr-init是比较麻烦的
于是我们可以在beans标签中添加default-lazy-init="true" 对所有的bean进行迟加载  
default-lazy-init 和 lazy-init 可以同时存在,比如 10个对象中 只有一个不需要迟加载,那么可以使用 default-lazy-init = true 全部设置迟加载,然后再去指定的bean中添加 lazy-init=false 就可以
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd"  default-lazy-init="true" >