【Spring笔记】总结spring的第一章

1. Spring简介

1.1 Spring介绍

Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯彻整个系统应用。Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的javaSE/EE full-stack(一站式)轻量级开源框架。
Spring是一个非常活跃的开源框架，基于IOC和AOP来构架多层javaEE系统，以帮助分离项目组件之间的依赖关系。他的主要目的是简化企业开发。
简单来说，Spring是一个分层的javaEE/EE full-stack(一站式) 轻量级开源框架。高内聚低耦合！！！
Spring春天、泉水！JAVAEE的春天来了！

1.2 Spring起源

RodJohnson在2002年编著的==《Expert one on one J2EE design and development》==一书中，对JavaEE系统框架臃肿、低效、脱离现实的种种现状提出了质疑，并积极寻求探索革新Spring logo之道。以此书为指导思想，他编写了interface21框架，这是一个力图冲破J2EE传统开发的困境，从实际需求出发，着眼于轻便、灵巧，易于开发、测试和部署的轻量级开发框架。Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日，发布了1.0正式版。同年他又推出了一部堪称经典的力作《Expert one-on-one J2EE Development without EJB》，该书在Java世界掀起了轩然大波，不断改变着Java开发者程序设计和开发的思考方式。在该书中，作者根据自己多年丰富的实践经验，对EJB的各种笨重臃肿的结构进行了逐一的分析和否定，并分别以简洁实用的方式替换之。至此一战功成，Rod Johnson成为一个改变Java世界的大师级人物。

1.3 Spring作用

• IOC思想 方便解耦，简化开发：Spring 就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring容器管理！

• AOP 编程(面向切面编程)的支持：Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能！

• 声明式事务的支持：只需要通过配置就可以完成对事务的管理，而无需手动编程 SSM SSS SSH

• 方便程序的测试：Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程序
  Spring-test ：Spring的测试模块！

• 方便集成各种优秀框架：Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts2、Hibernate、MyBatis、Quartz(定时任务)等）的直接支持
  Spring框架可以无缝整合其他的框架：MyBatis、Hibernate、Redis、Activiti、SpringMVC、SpringDATA。。。
  只要是框架，那么Spring就可以管理！

• 降低 JavaEE API 的使用难度：Spring对 JavaEE 开发中非常难用的API（JDBC、JavaMail、远程调用等），都提供了封装，使这些 API 应用难度大大降低

1.4 Spring的组成

Spring框架包含的功能大约由20个模块组成。这些模块按组可分为核心容器、数据访问/集成，Web，AOP(面向切面编程)、设备、消息和测试

2.Spring的作用

Spring可以解决业务逻辑层和其他各层的耦合问题，也是一个框架的粘合剂，它让面向接口编程思想贯穿了整个系统，特点：高内聚，低耦合，设计层框架！

2.1 IOC思想、AOP编程、声明式事务的支持、框架无缝整合其他框架

2.1.1 Spring环境搭建

<!-- pom.xml的配置 -->
   <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>4.3.7.RELEASE</version>
        </dependency>


        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.14</version>
        </dependency>

<!--以下是在resources中创建的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">
    <!--Spring AOP DI-->
    <!--spring容器创建对象，也是通过构造方法创建的，默认创建对象的方式是通过无参构造,依赖注入靠set方法-->
    <!--id是创建的对象的名字class表示对象是从Person这个类创建出来的-->
    <!--id="p1"(大名只能取一个) name="(小名可以取多个)"-->
    <!--scope(作用域属性):singleton单例 (默认)/prototype多例-->
    <!--lazy-init属性 对象的创建时机的设置 值：true（懒加载：用时才创建）/false（一启动就创建）-->
    <bean id="p1" name="person1,person2" class="com.swjd.bean.Person" scope="singleton"
    init-method="init" destroy-method="destroy">
        <!--DI就是给对象附属性值-->
        <property name="id" value="857"/>
        <property name="name" value="吕布"/>
        <property name="sex" value="男"/>
    </bean>
    <bean id="p2" name="person3,person4" class="com.swjd.bean.Person" scope="prototype" lazy-init="false">
        <!--DI就是给对象附属性值-->
        <property name="id" value="857"/>
        <property name="name" value="貂蝉"/>
        <property name="sex" value="女"/>
    </bean>
    <!--方式二：通过有参构造创建对象-->
    <bean id="p3" class="com.swjd.bean.Person">
        <constructor-arg index="0" type="int" value="859"/>
        <constructor-arg index="1" type="java.lang.String" value="艾希"/>
        <constructor-arg index="2" type="java.lang.String" value="女"/>
    </bean>
    <!--方式三:静态工厂-->
    <bean id="p4" class="com.swjd.beanfactory.PersonFactory" factory-method="createFactory"/>
    <!--方式四:通过非静态工厂创建对象-->
    <bean id="factory" class="com.swjd.beanfactory.NoStaticFactory"/>
    <bean id="p5" factory-bean="factory" factory-method="createFactory"/>
</beans>

2.1.2 IOC是什么？

控制反转，调用者的实例创建不再由调用者自己创建，而是由spring容器创建，这个过程把实例创建的控制权由应用代码转移到了外部容器，控制权发生了改变。

2.1.3 DI是什么？

依赖注入，给对象赋属性值，一定要保留空的构造方法和get/set的方法！

2.1.4 Bean标签里四个属性的作用：

（1）1.Name属性：给对象取名，名字可以同时取多个，但是不同的对象不能重复

（2）2.Scope对象作用域属性：

• scope = “singleton” 默认值，Spring容器默认创建的对象是单例！
• scope=“prototype” 创建的对象是多例（每次使用对象的时候额外创建一个新的
• scope=“session” 表示在一次会话范围内，Spring容器中的对象保持一个，公用同一个！
• scope=“request” 表示在一次请求范围内，Spring容器中的对象保持一个，公用同一个
  注意:后两个只能用在web项目里

（3）对象懒创建（只有在scope = "singleton"才会生效）lazy-init表示对象的加载时机(true:懒加载（使用对象的时候才创建）；false(spring框架一启动就加载))

（4）4.对象创建完成后调用的方法，和对象销毁后调用的方法
init-method=“对象创建完成后调用的方法”
destroy-method=“对象销毁后调用的方法”

2.1.5 spring创建对象的四种方式？

（1）用无参构造方法创建

<!--方式1：无参构造方法创建对象-->
 <bean id="p1" name="person1,person2" class="com.swjd.bean.Person" scope="singleton" lazy-init="true" init-method="init"  destroy-method="destroy">
     <property name="id" value="957"></property>
     <property name="name" value="貂蝉"></property>
     <property name="sex" value="女"></property>
  </bean>

（2）用带参的构造方法创建对象

<!--方式2：用带参的构造方法创建对象-->
<bean id="p3" class="com.swjd.bean.Person">
    <constructor-arg index="0" type="int" value="9528"></constructor-arg>
    <constructor-arg index="1" type="java.lang.String" value="德玛西亚"></constructor-arg>
    <constructor-arg index="2" type="java.lang.String" value="男"></constructor-arg>
</bean>

（3）用静态工厂创建对象

<!--方式3：用静态工厂创建对象-->
<bean id="p4" class="com.swjd.beanfactory.PersonFactory" factory-method="createPerson"></bean>

（4）用非静态工厂创建对象

<!--方式4：用非静态工厂创建对象-->
<bean id="noStaticfactory" class="com.swjd.beanfactory.NoStaticPersonFactory"></bean>
<bean id="p5" factory-bean="noStaticfactory" factory-method="createPerson"></bean>

2.1.6 Spring依赖注入的4种方式？

（1）.调用set方法注入

<bean id="m1" class="com.swjd.bean.Man">
    <!--第一种：依赖注入的方式：set注入-->
    <property name="id" value="1"/>
    <property name="name" value="刘德华"/>
    <property name="age" value="48"/>
   <!-- <property name="dog" ref="d1"/>-->
    <property name="dog">
        <ref bean="d1"/>
    </property>
</bean>

（2）.调用带参的构造方法注入

<bean id="m2" class="com.swjd.bean.Man">
    <!--第二种：依赖注入的方式：带参的构造方法-->
    <constructor-arg index="0" type="int" value="2"/>
    <constructor-arg index="1" type="java.lang.String" value="蔡徐坤"/>
    <constructor-arg index="2" type="int" value="20"/>
    <constructor-arg index="3" type="com.swjd.bean.Dog" ref="d1"/>
</bean>

（3）.P命名空间注入（本质依旧是set注入，语法简洁一些）

<bean id="m3" class="com.swjd.bean.Man" p:id="3" p:name="八戒" p:age="108" p:dog-ref="d1"></bean>

（4）.Spel表达式注入
<bean id="m4" class="com.swjd.bean.Man">
    <property name="id" value="#{m1.id}"></property>
    <property name="name" value="#{m2.name}"></property>
    <property name="age" value="#{m3.age}"></property>
</bean>

基本类型

复杂类型的注入：

(1)注入对象

(2)注入数组

<property name="hobbies" >
        <array>
            <value>123</value>
            <value>123</value>
        </array>
    </property>

(3)注入集合

List:
<property name="subject">
        <list>
            <value>1234</value>
            <value>1234</value>
        </list>
    </property>
    
Set：
 <property name="boyFriends">
        <set>
            <value>12345</value>
            <value>12345</value>
        </set>
    </property>

(4)注入map

  <property name="map">
        <map>
            <entry key="cn" value="中国"/>
            <entry key="ru" value="俄罗斯"/>
        </map>
    </property>