Spring浅谈

版权声明：本文为博主阿甘(Gane_Cheng)原创文章，欢迎转载，传播知识，请留言告知并注明出处，方便文章有误改正之后能找到原文。个人之言，请抱着怀疑的态度参考！ https://blog.csdn.net/Gane_Cheng/article/details/52759099

转载请注明出处：

http://blog.csdn.net/gane_cheng/article/details/52759099

http://www.ganecheng.tech/blog/52759099.html （浏览效果更好）

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个开源的控制反转(Inversion of Control ,IoC)和面向切面(AOP)的容器框架。它的主要目得是简化企业开发。

Spring是潜在地一站式解决方案，定位于与典型应用相关的大部分基础结构。它也涉及到其他framework没有考虑到的内容。

Spring致力于J2EE应用的各层的解决方案，而不是仅仅专注于某一层的方案。可以说Spring是企业应用开发的“一站式”选择，并贯穿表现层、业务层及持久层。然而，Spring并不想取代那些已有的框架，而是与它们无缝地整合。

Spring特点

1.方便解耦，简化开发

通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

2.AOP编程的支持

通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

3.声明式事务的支持

在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

4.方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。

5.方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。

6.降低Java EE API的使用难度

Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。

7.Java 源码是经典学习范例

Spring的源码设计精妙、结构清晰、匠心独运，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平，学习和研究Spring源码将会使你收到意想不到的效果。

Spring框架包括什么？

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式。

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

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

Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 MyBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

Spring 实现的两个核心技术 IoC 和 AOP

IoC—Inversion of Control，控制反转 ，在 Spring 里的实现是 Dependency Injection （ 依赖注入 ），就是说对象之间的依赖关系在后期通过配置文件（典型为 XML 文件）生成， Spring 里实现了两种注入方式：构造函数注入、 Setter 方法注入。我们可以这样理解这种技术带来的好处，前期我们只需要关注单个对象（组件）的功能实现，具体的业务实现是通过后期配置出来的，不同的配置可以产生不同的业务功能。

AOP—Aspect-oriented programming，面向切面编程。 AOP 大大降低了对象之间的耦合程度，与 IoC 一样，能够通过后期的配置动态为对象增加新的特性，甚至能够为对象动态增加方法。在 Spring 下， AOP 的实现不需要借助专门的 AOP 定义语言，只需要普通的 Java 对象和 XML 配置文件即可。

IoC 控制反转

public class PersonServiceBean {
     private PersonDao personDao = new PersonDaoBean();

      public void save(Person person){
            personDao.save(person);
     }
}

PersonDaoBean 是在应用内部创建及维护的。所谓控制反转就是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的。这样控制权就由应用转移到了外部容器，控制权的转移就是所谓反转。

当我们把依赖对象交给外部容器负责创建，那么PersonServiceBean 类可以改成如下：

public class PersonServiceBean 
{
     private PersonDao personDao ;
     //通过构造器参数，让容器把创建好的依赖对象注入进PersonServiceBean，当然也可以使用setter方法进行注入。
     public PersonServiceBean(PersonDao personDao)
     {
         this.personDao=personDao;
     }  
     public void save(Person person)
     {
            personDao.save(person);
     }
}

所谓依赖注入就是指：在运行期，由外部容器动态地将依赖对象注入到组件中。

为何要使用Spring

• 降低组件之间的耦合度,实现软件各层之间的解耦。
• 可以使用容器提供的众多服务，如：事务管理服务、消息服务等等。当我们使用容器管理事务时，开发人员就不再需要手工控制事务.也不需处理复杂的事务传播。
• 容器提供单例模式支持，开发人员不再需要自己编写实现代码。
• 容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。
• 容器提供的众多辅作类，使用这些类能够加快应用的开发，如： JdbcTemplate、 HibernateTemplate。
• Spring对于主流的应用框架提供了集成支持，如：集成Hibernate、JPA、Struts等，这样更便于应用的开发。

如果使用Spring, 我们就不再需要手工控制事务。

Hibernate的事务操作:

public void save()
{
    Session session = sessionFactory.getCurrentSession();

    //session.beginTransaction();

    Info info = new Info("传智播客");
    info.setContent("国内实力最强的java培训机构");
    session.save(info );

    //session.getTransaction().commit();
}

JDBC的事务操作:

Connection conn = null;
try 
{
     .......
     //conn.setAutoCommit(false);
     Statement stmt = conn.createStatement();
     stmt.executeUpdate("update person where name='叶天'");
     //conn.commit();
     .....
} 
//catch (Exception e) 
//{
//  conn.rollback();  
//} 
//finally
//{
//  conn.close();
//}

实例化spring容器

实例化Spring容器常用的两种方式：

方法一:
在类路径下寻找配置文件来实例化容器

ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{"beans.xml"});

方法二:
在文件系统路径下寻找配置文件来实例化容器

ApplicationContext ctx = new FileSystemXmlApplicationContext(new String[]{"d:\\beans.xml"}); 

Spring的配置文件可以指定多个，可以通过String数组传入。

当spring容器启动后，因为spring容器可以管理bean对象的创建，销毁等生命周期，所以我们只需从容器直接获取Bean对象就行，而不用编写一句代码来创建bean对象。从容器获取bean对象的代码如下：

ApplicationContext ctx = new ClassPathXmlApplicationContext(“beans.xml”);
OrderService service = (OrderService)ctx.getBean("personService");

实例化bean的方式

①使用Set方法实例化

set方式注入的属性一定要加set方法

/**通过set方法注入示例*/
public class IoC_By_Set {
    /**注入Integer类型参数*/
    private Integer id;
    /**注入String类型参数*/
    private String name;
    /**注入实体Bean*/
    private User user;
    /**注入数组*/
    private Object[] array;
    /**注入List集合*/
    private List<Object> list;
    /**注入Set集合*/
    private Set<Object> set;
    /**注入Map键值对*/
    private Map<Object, Object> map;
    /**注入properties类型*/
    private Properties properties;
    /**注入空字符串*/
    private String emptyValue;
    /**注入null值*/
    private String nullValue = "";

    /**检测注入的属性是否全部正确*/
    public boolean checkAttr() {
        if(id == null) {
            return false;
        }else {
            System.out.println("id:" + id);
        }
        System.out.println("--------------------------");
        if(name == null) {
            return false;
        }else {
            System.out.println("name:" + name);
        }
        System.out.println("--------------------------");
        if(user == null) {
            return false;
        }else {
            System.out.println("Bean:" + user.getId() + "|" + 
                    user.getUserName() + "|" + user.getPassWord());
        }
        System.out.println("--------------------------");
        if(array == null) {
            return false;
        }else {
            System.out.println("array:");
            for (Object object : array) {
                System.out.println(object.toString());
            }
        }
        System.out.println("--------------------------");
        if(list == null) {
            return false;
        }else {
            System.out.println("list:");
            for (Object object : list) {
                System.out.println(object.toString());
            }
        }
        System.out.println("--------------------------");
        if(set == null) {
            return false;
        }else {
            System.out.println("set:");
            for (Object object : set) {
                System.out.println(object.toString());

            }
        }
        System.out.println("--------------------------");
        if(map == null) {
            return false;
        }else {
            Set<Entry<Object, Object>> set = map.entrySet();
            System.out.println("map:");
            for (Entry<Object, Object> entry : set) {
                System.out.println(entry.getKey() + "|" + entry.getValue());
            }
        }
        System.out.println("--------------------------");
        if(properties == null) {
            return false;
        }else {
            Set<Entry<Object, Object>> set = properties.entrySet();
            System.out.println("properties:");
            for (Entry<Object, Object> entry : set) {
                System.out.println(entry.getKey() + "|" + entry.getValue());
            }
        }
        System.out.println("--------------------------");
        if(!"".equals(emptyValue))
            return false;
        System.out.println("--------------------------");
        if(!(null == nullValue))
            return false;
        System.out.println("--------------------------");
        System.out.println("全部正确！！！");
        return true;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public void setArray(Object[] array) {
        this.array = array;
    }

    public void setList(List<Object> list) {
        this.list = list;
    }

    public void setSet(Set<Object> set) {
        this.set = set;
    }

    public void setMap(Map<Object, Object> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void setEmptyValue(String emptyValue) {
        this.emptyValue = emptyValue;
    }

    public void setNullValue(String nullValue) {
        this.nullValue = nullValue;
    }

}

applicationContext.xml配置

 <!-- set方式注入 -->
    <bean id="ioC_By_Set" class="com.bc.ioc.demo01.IoC_By_Set">
        <!-- 注入id属性 -->
        <property name="id" value="1"/>
        <!-- 使用<![CDATA[]]>标记处理XML特 殊字符 -->
        <property name="name">
            <!-- 也可以使用P&amp;G -->
            <value><![CDATA[P&G]]></value>
        </property>
        <!-- 定义内部Bean注入 -->
        <property name="user">
            <bean class="com.bc.pojo.User">
                <property name="id" value="1"/>
                <property name="userName" value="内部Bean"/>
                <property name="passWord" value="233"/>
            </bean>
        </property>
        <!-- 注入数组类型 -->
        <property name="array">
            <array>
                <!-- 定义数组元素 -->
                <value>array01</value>
                <value>array02</value>
                <value>array03</value>
            </array>
        </property>
        <!-- 注入List类型 -->
        <property name="list">
            <list>
                <!-- 定义list中元素 -->
                <value>list01</value>
                <value>list02</value>
                <value>list03</value>
            </list>
        </property>
        <!-- 注入Set类型 -->
        <property name="set">
            <set>
                <!-- 定义set中元素 -->
                <value>set01</value>
                <value>set02</value>
                <value>set03</value>
            </set>
        </property>
        <!-- 注入Map类型 -->
        <property name="map">
            <map>
                <!-- 定义map中的键值对 -->
                <entry>
                    <key>
                        <value>mapKey01</value>
                    </key>
                    <value>mapValue01</value>
                </entry>
                <entry>
                    <key>
                        <value>mapKey02</value>
                    </key>
                    <value>mapValue02</value>
                </entry>
            </map>
        </property>
        <!-- 注入properties类型 -->
        <property name="properties">
            <props>
                <!-- 定义properties中的键值对 -->
                <prop key="propKey1">propValue1</prop>
                <prop key="propKey2">propValue2</prop>
            </props>
        </property>
        <!-- 注入空字符串 -->
        <property name="emptyValue">
            <value></value>
        </property>
        <!-- 注入null值 -->
        <property name="nullValue">
            <null/>
        </property>
    </bean>

测试代码

public class IoC_Test {

    private ApplicationContext ctx;

    @Before
    public void load() {
        //读取applicationContext.xml配置文件
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    @Test
    public void SetTest() {
        IoC_By_Set ioc = (IoC_By_Set) ctx.getBean("ioC_By_Set");
        ioc.checkAttr();
    }
}

②通过构造方法注入各种类型属性

注意：使用JDK1.8版本请将spring相关jar包升级到4.x版本以上,否则不兼容构造方法注入

/** 通过构造方法注入示例 */
public class IoC_By_Constructor {

    private Integer id;
    private String name;
    private User user;
    private List<Object> list;

    public IoC_By_Constructor() {
    }

    public IoC_By_Constructor(Integer id, String name, User user,
            List<Object> list) {
        this.id = id;
        this.name = name;
        this.user = user;
        this.list = list;
    }

    /**检查是否注入成功*/
    public boolean checkAttr() {
        if(id == null) {
            return false;
        }else {
            System.out.println("id:" + id);
        }
        System.out.println("----------------------------");
        if(name == null) {
            return false;
        }else {
            System.out.println("name:" + name);
        }
        System.out.println("----------------------------");
        if(user == null) {
            return false;
        }else {
            System.out.println("user:" + user.getId() + "|" + 
                    user.getUserName() + "|" + user.getPassWord());
        }
        System.out.println("----------------------------");
        if(list == null) {
            return false;
        }else {
            System.out.println("list:");
            for (Object object : list) {
                System.out.println(object.toString());
            }
        }
        System.out.println("----------------------------");
        System.out.println("全部正确！！！");
        return true;
    }
}

applicationContext.xml配置

    <!-- 构造方法注入 演示几种类型-->
    <bean id="ioC_By_Constructor" class="com.bc.ioc.demo02.IoC_By_Constructor">
        <!-- 注入Integer属性,可以选择使用index指定参数位置,也可以选择使用type指定参数类型 -->
        <constructor-arg index="0" value="1" type="java.lang.Integer"/>
        <!-- 注入字符串 -->
        <constructor-arg value="P&amp;G"/>
        <!-- 注入对象 -->
        <constructor-arg>
            <!-- 内建对象 -->
            <bean class="com.bc.pojo.User">
                <constructor-arg value="1"/>
                <constructor-arg value="构造内部Bean"/>
                <constructor-arg value="666"/>
            </bean>
        </constructor-arg>
        <!-- 注入集合 -->
        <constructor-arg>
            <list>
                <value>list01</value>
                <value>list02</value>
                <value>list03</value>
            </list>
        </constructor-arg>
    </bean>

测试代码：

public class IoC_Test {

    private ApplicationContext ctx;

    @Before
    public void load() {
        //读取applicationContext.xml配置文件
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    @Test
    public void constructorTest() {
        IoC_By_Constructor ioc = (IoC_By_Constructor) ctx.getBean("ioC_By_Constructor");
        ioc.checkAttr();
    }

}

③自动注入(自动装配)

/**自动装配注入*/
public class IoC_By_Auto {

    private User user;

    /**检查是否注入成功*/
    public boolean checkAttr() {
        if(user == null) {
            return false;
        }else {
            System.out.println("user:" + user.getId() + "|" + 
                    user.getUserName() + "|" + user.getPassWord());
        }
        System.out.println("正确！！！");
        return true;
    }

    /**自动装配的属性需要设置set方法*/
    public void setUser(User user) {
        this.user = user;
    }

}

applicationContext.xml配置

    <!-- 被自动装配获取的bean -->
    <bean id="user" class="com.bc.pojo.User">
        <property name="id" value="1"/>
        <property name="userName" value="自动装配"/>
        <property name="passWord" value="233"/>
    </bean>
    <!-- 自动装配的bean
         autowire:byName 根据类的属性名查找与之命名相同的id的bean进行装配
                  byType 根据类的属性类型查找唯一一个匹配类型的bean,如果有多个bean匹配则抛出异常
                  constructor 根据类的构造方法参数类型匹配对应的bean
                  no 默认,表示不使用自动装配
                  default：由上级标签<beans>的default-autowire属性确定 -->
    <bean id="ioC_By_Auto" class="com.bc.ioc.demo03.IoC_By_Auto" autowire="byName"></bean>

测试代码

public class IoC_Test {

    private ApplicationContext ctx;

    @Before
    public void load() {
        //读取applicationContext.xml配置文件
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    @Test
    public void AutoTest() {
        IoC_By_Auto ioc = (IoC_By_Auto) ctx.getBean("ioC_By_Auto");
        ioc.checkAttr();
    }

}

④使用P命名空间注入属性

使用 < property > 和命名空间P是等价的。但是使用命名空间P可以省去很多的尖括号。

使用 < property >的效果如下。

    <bean id="user2" class="com.bc.pojo.User">
        <property name="id" value="1"/>
        <property name="userName" value="P"/>
        <property name="passWord" value="233"/>
    </bean>

使用命名空间P的效果如下。

<bean id="ioC_By_P" class="com.bc.ioc.demo04.IoC_By_P" p:id="1" 
        p:name="命名空间" p:user-ref="user2"></bean>

/**使用P命名空间注入*/
public class IoC_By_P {

    private Integer id;
    private String name;
    private User user;

    /**检查是否注入成功*/
    public boolean checkAttr() {
        if(id == null) {
            return false;
        }else {
            System.out.println("id:" + id);
        }
        System.out.println("----------------------------");
        if(name == null) {
            return false;
        }else {
            System.out.println("name:" + name);
        }
        System.out.println("----------------------------");
        if(user == null) {
            return false;
        }else {
            System.out.println("user:" + user.getId() + "|" + 
                    user.getUserName() + "|" + user.getPassWord());
        }
        System.out.println("----------------------------");
        System.out.println("全部正确！！！");
        return true;
    }

    //使用P命名空间注入属性需要设置set方法
    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setUser(User user) {
        this.user = user;
    }

}

applicationContext.xml配置

    <!-- 使用P命名空间注入各种类型属性 -->
    <bean id="user2" class="com.bc.pojo.User">
        <property name="id" value="1"/>
        <property name="userName" value="P"/>
        <property name="passWord" value="233"/>
    </bean>
    <bean id="ioC_By_P" class="com.bc.ioc.demo04.IoC_By_P" p:id="1" 
        p:name="命名空间" p:user-ref="user2"></bean>

测试代码

public class IoC_Test {

    private ApplicationContext ctx;

    @Before
    public void load() {
        //读取applicationContext.xml配置文件
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    @Test
    public void PTest() {
        IoC_By_P ioc = (IoC_By_P) ctx.getBean("ioC_By_P");
        ioc.checkAttr();
    }

}

⑤ 使用注解方式注入

Spring在2.5以后，提供了基于Annotation（注解）的注入。

1.@Autowired -对成员变量、方法和构造函数进行标注，来完成自动装配的工作，不推荐使用

    @Autowired 
    private PersonDao  personDao;//用于字段上
    @Autowired
    public void setOrderDao(OrderDao orderDao) {//用于属性的setter方法上
        this.orderDao = orderDao;
    }

2.@Qualifier -配合@Autowired来解决装配多个同类型的bean

    @Autowired  @Qualifier("personDaoBean")
    private PersonDao  personDao;

3.@Resource -JSR-250标准注解，作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按byName自动注入 ，当找不到与名称匹配的bean才会按类型装配。

@Resource注解和@Autowired一样，也可以标注在字段或属性的setter方法上，但它默认按名称装配。名称可以通过@Resource的name属性指定，如果没有指定name属性，当注解标注在字段上，即默认取字段的名称作为bean名称寻找依赖对象，当注解标注在属性的setter方法上，即默认取属性名作为bean名称寻找依赖对象。

    @Resource(name=“personDaoBean”)
    private PersonDao  personDao;//用于字段上

注意：如果没有指定name属性，并且按照默认的名称仍然找不到依赖对象时， @Resource注解会回退到按类型装配。但一旦指定了name属性，就只能按名称装配了。

4.@PostConstruct -在方法上加上注解@PostConstruct，这个方法就会在Bean初始化之后被Spring容器执行

5.@PreDestroy -在方法上加上注解@PreDestroy，这个方法就会在Bean初始化之后被Spring容器执行

6.@Component -只需要在对应的类上加上一个@Component注解，就将该类定义为一个Bean，不推荐使用，推荐使用更加细化的三种：@Repository、@Service、@Controller

@Repository 存储层Bean
@Service 业务层Bean
@Controller 控制器层Bean

7.@Scope -定义Bean的作用范围

singleton

在每个Spring IoC容器中一个bean定义只有一个对象实例。默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean才会初始化bean。如：

 <bean id="xxx" class="cn.itcast.OrderServiceBean" lazy-init="true"/>

如果想对所有bean都应用延迟初始化，可以在根节点beans设置default-lazy-init=“true“，如下：

<beans default-lazy-init="true" ...>  作用域为protoype时 也是延迟初始化

prototype
每次从容器获取bean都是新的对象。

request
session
global session

---

首先配置applicationContext.xml开启注解，开启扫描。

    <!-- 扫描包中注解标注的类 -->
    <context:component-scan base-package="com.bc.ioc.demo05"/>

实体Bean加注解

@Repository
public class User {

    private Integer id = 1;

    private String userName = "注解注入";

    private String passWord = "233";

    public User() {
        super();
    }

    public User(Integer id, String userName, String passWord) {
        super();
        this.id = id;
        this.userName = userName;
        this.passWord = passWord;
    }

    public Integer getId() {
        return id;
    }

    public String getUserName() {
        return userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

}

测试类代码加注解

/**使用注解注入属性*/
@Service("ioC_By_Annotation")
public class IoC_By_Annotation {
    @Resource
    private User user;

    public void setUser(User user) {
        this.user = user;
    }

    /**检查是否注入成功*/
    public boolean checkAttr() {
        if(user == null) {
            return false;
        }else {
            System.out.println("user:" + user.getId() + "|" + 
                    user.getUserName() + "|" + user.getPassWord());
        }
        System.out.println("正确！！！");
        return true;
    }
}

测试代码

public class IoC_Test {

    private ApplicationContext ctx;

    @Before
    public void load() {
        //读取applicationContext.xml配置文件
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    @Test
    public void annotationTest() {
        IoC_By_Annotation ioc = (IoC_By_Annotation) ctx.getBean("ioC_By_Annotation");
        ioc.checkAttr();
    }

}

⑥ 通过配置静态工厂方法Bean注入

静态工厂代码

/**静态工厂*/
public class StaticFactory {

    public static Integer getId() {
        return 1;
    }

    public static String getName() {
        return "静态工厂";
    }

    public static User getUser() {
        return new User(1, "工厂User", "666");
    }
}

测试类代码

/** 通过静态工厂方式注入 */
public class IoC_By_StaticFactory {

    private Integer id;
    private String name;
    private User user;

    /** 检查是否注入成功 */
    public boolean checkAttr() {
        if (id == null) {
            return false;
        } else {
            System.out.println("id:" + id);
        }
        System.out.println("----------------------------");
        if (name == null) {
            return false;
        } else {
            System.out.println("name:" + name);
        }
        System.out.println("----------------------------");
        if (user == null) {
            return false;
        } else {
            System.out.println("user:" + user.getId() + "|"
                    + user.getUserName() + "|" + user.getPassWord());
        }
        System.out.println("----------------------------");
        System.out.println("全部正确！！！");
        return true;
    }

    /**需要为需要注入的属性设置set方法*/
    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setUser(User user) {
        this.user = user;
    }

}

applicationContext.xml配置

    <!-- 配置静态工厂方法Bean 其实就是将工厂方法返回的数值配置成Bean -->
    <bean id="factory_id" class="com.bc.ioc.demo06.StaticFactory" factory-method="getId"/>
    <bean id="factory_name" class="com.bc.ioc.demo06.StaticFactory" factory-method="getName"/>
    <bean id="factory_user" class="com.bc.ioc.demo06.StaticFactory" factory-method="getUser"/>
    <!-- 注入对应的静态工厂方法Bean -->
    <bean id="ioC_By_StaticFactory" class="com.bc.ioc.demo06.IoC_By_StaticFactory">
        <property name="id" ref="factory_id"/>
        <property name="name" ref="factory_name"/>
        <property name="user" ref="factory_user"/>
    </bean>

测试代码

public class IoC_Test {

    private ApplicationContext ctx;

    @Before
    public void load() {
        //读取applicationContext.xml配置文件
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    @Test
    public void staticFactoryTest() {
        IoC_By_StaticFactory ioc = (IoC_By_StaticFactory) ctx.getBean("ioC_By_StaticFactory");
        ioc.checkAttr();
    }
}

⑦ 通过实例工厂方法注入

与静态工厂区别在于实例工厂不是静态的,需要先new 一个实例工厂对象,才可以配置其方法,而new 的这个对象也由spring来管理

工厂代码

/**实例工厂*/
public class Factory {

    public Integer getId() {
        return 1;
    }

    public String getName() {
        return "实例工厂";
    }

    public User getUser() {
        return new User(1, "实例工厂User", "233");
    }
}

测试类代码

/**实例工厂注入*/
public class IoC_By_Factory {

    private Integer id;
    private String name;
    private User user;

    /** 检查是否注入成功 */
    public boolean checkAttr() {
        if (id == null) {
            return false;
        } else {
            System.out.println("id:" + id);
        }
        System.out.println("----------------------------");
        if (name == null) {
            return false;
        } else {
            System.out.println("name:" + name);
        }
        System.out.println("----------------------------");
        if (user == null) {
            return false;
        } else {
            System.out.println("user:" + user.getId() + "|"
                    + user.getUserName() + "|" + user.getPassWord());
        }
        System.out.println("----------------------------");
        System.out.println("全部正确！！！");
        return true;
    }

    /**需要为需要注入的属性设置set方法*/
    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

applicationContext.xml配置

    <!-- 配置实例工厂Bean -->
    <bean id="factory" class="com.bc.ioc.demo07.Factory"/>
    <!-- 配置实例工厂方法Bean -->
    <bean id="f_id" factory-bean="factory" factory-method="getId"/>
    <bean id="f_name" factory-bean="factory" factory-method="getName"/>
    <bean id="f_user" factory-bean="factory" factory-method="getUser"/>
    <!-- 注入对应的实例工厂方法Bean -->
    <bean id="ioC_By_Factory" class="com.bc.ioc.demo07.IoC_By_Factory">
        <property name="id" ref="f_id"/>
        <property name="name" ref="f_name"/>
        <property name="user" ref="f_user"/>
    </bean>

测试类代码

public class IoC_Test {

    private ApplicationContext ctx;

    @Before
    public void load() {
        //读取applicationContext.xml配置文件
        ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    }

    @Test
    public void factoryTest() {
        IoC_By_Factory ioc = (IoC_By_Factory) ctx.getBean("ioC_By_Factory");
        ioc.checkAttr();
    }
}

AOP 面向切面编程

*如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP

*如果目标对象实现了接口，可以强制使用CGLIB实现AOP

*如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

如何强制使用CGLIB实现AOP？

• 添加CGLIB库，SPRING_HOME/cglib/*.jar
• 在spring配置文件中加入
• <aop:aspectj-autoproxy proxy-target-class="true"/>

JDK动态代理和CGLIB字节码生成的区别？

• JDK动态代理只能对实现了接口的类生成代理，而不能针对类。

public class JDKProxy implements InvocationHandler 
{
    private Object targetObject;//代理的目标对象
    public Object createProxyInstance(Object targetObject)
    {
        this.targetObject = targetObject;
        /*
        * 第一个参数设置代码使用的类装载器,一般采用跟目标类相同的类装载器
        * 第二个参数设置代理类实现的接口
        * 第三个参数设置回调对象,当代理对象的方法被调用时,会委派给该参数指定对象的invoke方法
        */
        return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),
                this.targetObject.getClass().getInterfaces(), this);
    }
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable 
    {
        return method.invoke(this.targetObject, args);//把方法调用委派给目标对象
    }
}

• CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法。因为是继承，所以该类或方法最好不要声明成final。

public class CGLIBProxy implements MethodInterceptor 
{
    private Object targetObject;//代理的目标对象   
    public Object createProxyInstance(Object targetObject)
    {
        this.targetObject = targetObject;
        Enhancer enhancer = new Enhancer();//该类用于生成代理对象
        enhancer.setSuperclass(this.targetObject.getClass());//设置父类
        enhancer.setCallback(this);//设置回调用对象为本身
        return enhancer.create();
    }
    public Object intercept(Object proxy, Method method, Object[] args,
            MethodProxy methodProxy) throws Throwable
    {
        return methodProxy.invoke(this.targetObject, args);
    }

}

AOP中的概念

Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面横切性关注点的抽象.

joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)

Pointcut(切入点):所谓切入点是指我们要对那些joinpoint进行拦截的定义.

Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知

　　Interception Around环绕通知：JointPoint前后调用

　　Before前置通知：JointPoint前调用

　　After Returning后置通知：JointPoint后调用

　　Throw异常通知：JoinPoint抛出异常时调用

　　Introduction最终通知：JointPoint调用完毕后调用

Target(目标对象):代理的目标对象

Weave(织入):指将aspects应用到target对象并导致proxy对象创建的过程称为织入.

Introduction(引入):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

---

Spring提供了两种切面声明方式，实际工作中我们可以选用其中一种：

基于注解方式声明切面。
基于XML配置方式声明切面。

基于注解方式声明切面

首先启动对@AspectJ注解的支持(<aop:aspectj-autoproxy/>)：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
     <aop:aspectj-autoproxy/>
    <bean id="orderservice" class="cn.itcast.service.OrderServiceBean"/>
    <bean id="log" class="cn.itcast.service.LogPrint"/>
</beans>

@Aspect
public class LogPrint 
{
    @Pointcut("execution(* cn.itcast.service..*.*(..))")
    private void anyMethod() {}//声明一个切入点    

    @Before("anyMethod() && args(userName)")//定义前置通知
    public void doAccessCheck(String userName) {    }   

    @AfterReturning(pointcut="anyMethod()",returning="revalue")//定义后置通知
    public void doReturnCheck(String revalue) { }

    @AfterThrowing(pointcut="anyMethod()", throwing="ex")//定义例外通知
    public void doExceptionAction(Exception ex) {   }

    @After("anyMethod()")//定义最终通知
    public void doReleaseAction() { }

    @Around("anyMethod()")//环绕通知
    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable 
    {
        return pjp.proceed();
    }
}

基于基于XML配置方式声明切面

public class LogPrint 
{
    public void doAccessCheck() {}//定义前置通知
    public void doReturnCheck() {}//定义后置通知
    public void doExceptionAction() {}//定义例外通知
    public void doReleaseAction() {}//定义最终通知
    //定义环绕通知
    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable 
    {
        return pjp.proceed();
    }
}

<bean id="orderservice" class="cn.itcast.service.OrderServiceBean"/>
<bean id="log" class="cn.itcast.service.LogPrint"/>
<aop:config>
  <aop:aspect id="myaop" ref="log">
    <aop:pointcut id="mycut" expression="execution(* cn.itcast.service..*.*(..))"/>
    <aop:before pointcut-ref="mycut" method="doAccessCheck"/>
    <aop:after-returning pointcut-ref="mycut" method="doReturnCheck "/>
    <aop:after-throwing pointcut-ref="mycut" method="doExceptionAction"/>
    <aop:after pointcut-ref="mycut" method=“doReleaseAction"/>
    <aop:around pointcut-ref="mycut" method="doBasicProfiling"/>
  </aop:aspect>
</aop:config>

Spring 事务

采用注解方式配置事务

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!– 采用@Transactional注解方式使用事务  -->
<tx:annotation-driven transaction-manager="txManager"/>

@Service @Transactional
public class PersonServiceBean implements PersonService 
{
}

采用基于XML方式配置事务

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
<aop:config>
    <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config> 
<tx:advice id="txAdvice" transaction-manager="txManager">
      <tx:attributes>
        <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
        <tx:method name="*"/>
      </tx:attributes>
</tx:advice>

Spring事务的7种传播行为，5种隔离级别。

传播行为	含义
PROPAGATION_REQUIRED	支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY	支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW	新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER	以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED	如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

---

① PROPAGATION_REQUIRED

假如当前正要执行的事务不在另外一个事务里，那么就起一个新的事务

比如说，ServiceB.methodB的事务级别定义为PROPAGATION_REQUIRED, 那么由于执行ServiceA.methodA的时候，ServiceA.methodA已经起了事务，这时调用ServiceB.methodB，ServiceB.methodB看到自己已经运行在ServiceA.methodA的事务内部，就不再起新的事务。而假如ServiceA.methodA运行的时候发现自己没有在事务中，他就会为自己分配一个事务。这样，在ServiceA.methodA或者在ServiceB.methodB内的任何地方出现异常，事务都会被回滚。即使ServiceB.methodB的事务已经被提交，但是ServiceA.methodA在接下来fail要回滚，ServiceB.methodB也要回滚。

② PROPAGATION_SUPPORTS

如果当前在事务中，即以事务的形式运行，如果当前不再一个事务中，那么就以非事务的形式运行

③ PROPAGATION_MANDATORY

必须在一个事务中运行。也就是说，他只能被一个父事务调用。否则，他就要抛出异常。

④ PROPAGATION_REQUIRES_NEW

这个就比较绕口了。 比如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED，ServiceB.methodB的事务级别为PROPAGATION_REQUIRES_NEW，那么当执行到ServiceB.methodB的时候，ServiceA.methodA所在的事务就会挂起，ServiceB.methodB会起一个新的事务，等待ServiceB.methodB的事务完成以后，他才继续执行。他与PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为ServiceB.methodB是新起一个事务，那么就是存在两个不同的事务。如果ServiceB.methodB已经提交，那么ServiceA.methodA失败回滚，ServiceB.methodB是不会回滚的。如果ServiceB.methodB失败回滚，如果他抛出的异常被ServiceA.methodA捕获，ServiceA.methodA事务仍然可能提交。

⑤ PROPAGATION_NOT_SUPPORTED

当前不支持事务。比如ServiceA.methodA的事务级别是PROPAGATION_REQUIRED ，而ServiceB.methodB的事务级别是PROPAGATION_NOT_SUPPORTED ，那么当执行到ServiceB.methodB时，ServiceA.methodA的事务挂起，而他以非事务的状态运行完，再继续ServiceA.methodA的事务。

⑥ PROPAGATION_NEVER

不能在事务中运行。假设ServiceA.methodA的事务级别是PROPAGATION_REQUIRED， 而ServiceB.methodB的事务级别是PROPAGATION_NEVER ，那么ServiceB.methodB就要抛出异常了。

⑦ PROPAGATION_NESTED

理解Nested的关键是savepoint。他与PROPAGATION_REQUIRES_NEW的区别是，PROPAGATION_REQUIRES_NEW另起一个事务，将会与他的父事务相互独立，而Nested的事务和他的父事务是相依的，他的提交是要等和他的父事务一块提交的。也就是说，如果父事务最后回滚，他也要回滚的。
而Nested事务的好处是他有一个savepoint。

---

隔离级别	含义
ISOLATION_DEFAULT	这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应
ISOLATION_READ_UNCOMMITTED	这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读
ISOLATION_READ_COMMITTED	保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现，但是可能会出现不可重复读和幻像读。
ISOLATION_REPEATABLE_READ	这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。
ISOLATION_SERIALIZABLE	这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。

---

脏读：一个事务读取到另一事务未提交的更新新据。

不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同。换句话说就是，后续读取可以读到另一事务已提交的更新数据。相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是，后续读取不能读到另一事务已提交的更新数据。

幻读：一个事务读取到另一事务已提交的insert数据。

---

参考文献

http://baike.baidu.com/item/spring

http://v.itcast.cn/course/41.html

http://blog.csdn.net/voyage_mh1987/article/details/5755729

http://blog.csdn.net/xiaohai0504/article/details/6832990

http://blog.csdn.net/qq_32588349/article/details/51554379

http://blog.csdn.net/u011285162/article/details/19247711

http://blog.csdn.net/paincupid/article/details/48185597

http://blog.csdn.net/it_wangxiangpan/article/details/24180085

http://docs.spring.io/spring-framework/docs/current/spring-framework-reference/html/overview.html