Spring详细总结

Spring的特性之一：IOC(控制反转Inverse Of Control)，又称依赖注入，是一种重要的面向对象编程的法则来削减计算机程序的耦合问题

也是轻量级spring框架的核心；

依赖注入：

1.属性注入

beans.xml配置实例：

<bean id="people2" class="com.java1234.entity.People">
  <property name="id" value="1"></property>
  <property name="name" value="张三"></property>
  <property name="age" value="11"></property>
 </bean>

2.构造器注入：（通过类型；索引；联合使用）

类型配置实例：

<bean id="people3" class="com.java1234.entity.People">
  <constructor-arg type="int" value="2"></constructor-arg>
  <constructor-arg type="String" value="李四"></constructor-arg>
  <constructor-arg type="int" value="22"></constructor-arg>-------构造器注入对应的People类必须有带这3个参数的构造器（此时可以没有get/set方法）
 </bean>

索引配置实例：

<bean id="people4" class="com.java1234.entity.People">
  <constructor-arg index="0" value="3"></constructor-arg>
  <constructor-arg index="1" value="王五"></constructor-arg>
  <constructor-arg index="2" value="55"></constructor-arg>
 </bean>

联合使用

<bean id="people5" class="com.java1234.entity.People">
  <constructor-arg index="0" type="int" value="4"></constructor-arg>
  <constructor-arg index="1" type="String" value="招六"></constructor-arg>
  <constructor-arg index="2" type="int" value="66"></constructor-arg>
 </bean>

3.工厂注入（非静态工厂；静态工厂）

非静态工厂：

<bean id="peopleFactory" class="com.java1234.factory.PeopleFactory"></bean>
 <bean id="people7" factory-bean="peopleFactory" factory-method="createPeople"></bean>
 静态工厂：

<bean id="people8" class="com.java1234.factory.PeopleFactory2" factory-method="createPeople"></bean>

《静态工厂不用创建对象，所以可以一步完成》

4.泛型依赖注入(整合Hibernate的时候讲)

注入参数：

1.属性注入 2.bean注入(<property name="dog" ref="...."></property>) 3.内部bean注入 4.null值 5.级联属性 6.集合类型属性

内部bean注入xml配置实例

<bean id="people3" class="com.java1234.entity.People">
  <property name="id" value="1"></property>
  <property name="name" value="张三"></property>
  <property name="age" value="11"></property>
  <property name="dog">
   <bean class="com.java1234.entity.Dog">
    <property name="name" value="Tom"></property>
   </bean>
  </property>
 </bean>

注入null值实例：

<bean id="people4" class="com.java1234.entity.People">
  <property name="id" value="1"></property>
  <property name="name" value="张三"></property>
  <property name="age" value="11"></property>
  <property name="dog">
   <null></null>
  </property>
 </bean>

list，property注入：

<bean id="people6" class="com.java1234.entity.People">
  <property name="id" value="1"></property>
  <property name="name" value="张三"></property>
  <property name="age" value="11"></property>
  <property name="dog" ref="dog1"></property>
  <property name="hobbies">
   <list>
    <value>唱歌</value>
    <value>跳舞</value>
   </list>
  </property>
  <property name="loves">
   <set>
    <value>唱歌2</value>
    <value>跳舞2</value>
   </set>
  </property>
  <property name="works">
   <map>
    <entry>
     <key><value>上午</value></key>
     <value>写代码</value>
    </entry>
    <entry>
     <key><value>下午</value></key>
     <value>测试代码</value>
    </entry>
   </map>
  </property>
  <property name="addresses">
   <props>
    <prop key="address1">aaaaa</prop>
    <prop key="address2">bbbbb</prop>
   </props>
  </property>
 </bean>
 

Spring的自动装配：通过default-autowire属性来进行装配，其类型有byName,byType,constructor

例如在beans.xml配置：default-autowire="constructor">

bean id="dog2" class="com.java1234.entity.Dog">
  <property name="name" value="Jack"></property>
 </bean>
 
 <bean id="people1" class="com.java1234.entity.People">
  <property name="id" value="1"></property>
  <property name="name" value="张三"></property>
  <property name="age" value="11"></property>
 
 </bean>

在People类里面就会调用下面的构造器：

public People(Dog dog) {
  super();
  System.out.println("constructor11");
  this.dog = dog;
 }

---自动装配要慎用，其屏蔽了装配细节，容易产生潜在的错误；

Spring bean作用域默认是 单例singleton  可以通过配置scope="prototype",实现多例

bean之间的关系：

继承；依赖；引用

继承：配置实例如下：

<bean id="abstractPeople" class="com.java1234.entity.People" abstract="true">
  <property name="className" value="高三5班"></property>
  <property name="age" value="19"></property>
 </bean>
 <bean id="zhangsan" parent="abstractPeople" depends-on="autority">
  <property name="id" value="1"></property>
  <property name="name" value="张三"></property>
 </bean>

---继承会有重写；

depends-on="autority">体现了依赖，如果不加autority这个bean的实例化按照beans.xml中的顺序

Spring的另外一个特性AOP

面向切面编程，主要功能：日志记录，性能统计，安全控制，事务处理，异常处理

简单实例(前置---环绕通知)

<?xml version="1.0" encoding="UTF-8"?>

<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.xsd        

http://www.springframework.org/schema/aop        

http://www.springframework.org/schema/aop/spring-aop.xsd">  

<bean id="studentServiceAspect" class="com.java1234.advice.StudentServiceAspect">

</bean>    

<bean id="studentService" class="com.java1234.service.impl.StudentServiceImpl">

</bean>     

<aop:config>   

<aop:aspect id="studentServiceAspect" ref="studentServiceAspect">    

<aop:pointcut expression="execution(* com.java1234.service.*.*(..))" id="businessService"/>    

<aop:before method="doBefore" pointcut-ref="businessService"/>    

<aop:after method="doAfter" pointcut-ref="businessService"/>   

 <aop:around method="doAround" pointcut-ref="businessService"/>    

<aop:after-returning method="doAfterReturning" pointcut-ref="businessService"/>    

<aop:after-throwing method="doAfterThrowing" pointcut-ref="businessService" throwing="ex"/>   

</aop:aspect>  </aop:config>

</beans>

--前置通知

public void doBefore(JoinPoint jp){
  System.out.println("类名:"+jp.getTarget().getClass().getName());
  System.out.println("方法名："+jp.getSignature().getName());
  System.out.println("开始添加学生："+jp.getArgs()[0]);
 }

--环绕通知

public Object doAround(ProceedingJoinPoint pjp) throws Throwable{
  System.out.println("添加学生前");
  Object retVal=pjp.proceed();
  System.out.println(retVal);
  System.out.println("添加学生后");
  return retVal;
 }

--异常通知

public void doAfterThrowing(JoinPoint jp,Throwable ex){
  System.out.println("异常通知");
  System.out.println("异常信息："+ex.getMessage());
 }

 Spring对jdbc的支持：beans.xml配置文件的部分代码

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

/*

也可以通过如下C3P0数据源实现

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"        destroy-method="close">       
     <property name="driverClass" value=" oracle.jdbc.driver.OracleDriver "/>       
   <property name="jdbcUrl" value=" jdbc:oracle:thin:@localhost:1521:ora9i "/>       
  <property name="user" value="admin"/>       
   <property name="password" value="1234"/>       
bean>  

*/
 <context:property-placeholder location="jdbc.properties"/>//通过这个属性就可以在properties文件中取找

/*也可以通过如下写法

<bean id="propertyConfigurer"   class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">       
<property name="location" value="/WEB-INF/jdbc.properties"/>       
bean>       

*/
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
     <property name="dataSource" ref="dataSource"></property>//将数据源注入到jdbcTemplate类
    </bean>
 <bean id="studentDao" class="com.java1234.dao.impl.StudentDaoImpl">
  <property name="jdbcTemplate" ref="jdbcTemplate"></property>//将jdbc注入到业务层，这样就可以通过实现类的方法进行对表的操作
 </bean>

上面使用的是jdbcTemplate

还可以通过：JdbcDaoSupport(此时beans.xml中直接将数据源注入到实现类，实现类继承JdbcDaoSupport<public class StudentDaoImpl extends JdbcDaoSupport implements StudentDao>)

增加的写法：

public int addStudent(Student student) {
  String sql="insert into t_student values(null,?,?)";
  Object []params=new Object[]{student.getName(),student.getAge()};
  return this.getJdbcTemplate().update(sql,params);
 }

NamedParameterJdbcTemplate

增加的写法：

@Override
 public int addStudent(Student student) {
  String sql="insert into t_student values(null,:name,:age)";
  MapSqlParameterSource sps=new MapSqlParameterSource();
  sps.addValue("name", student.getName());
  sps.addValue("age", student.getAge());
  return namedParameterJdbcTemplate.update(sql,sps);
 }

--将数据源注入这3个类，再将这个类注入到业务层，都可以实现增删改查

Spring对事务的支持：

beans.xml文件的配置：

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
   
    <!-- jdbc事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource" ref="dataSource"></property>
    </bean>
   
    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
     <property name="transactionManager" ref="transactionManager"></property>
    </bean>//将这个template对象注入到业务类
     
 <context:property-placeholder location="jdbc.properties"/>
   
    <bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
     <constructor-arg ref="dataSource"></constructor-arg>
    </bean>
 
 <bean id="bankDao" class="com.java1234.dao.impl.BankDaoImpl">
  <property name="namedParameterJdbcTemplate" ref="namedParameterJdbcTemplate"></property>
 </bean>
 
 <bean id="bankService" class="com.java1234.service.impl.BankServiceImpl">
  <property name="bankDao" ref="bankDao"></property>
  <property name="transactionTemplate" ref="transactionTemplate"></property>
 </bean>
在业务类中就可以按照如下操作：

@Override
 public void transferAccounts(final int count, final int userIdA, final int userIdB) {
  // TODO Auto-generated method stub
  transactionTemplate.execute(new TransactionCallbackWithoutResult() {
   @Override
   protected void doInTransactionWithoutResult(TransactionStatus arg0) {
    // TODO Auto-generated method stub
    bankDao.outMoney(count, userIdA);
    bankDao.inMoney(count, userIdB);    
   }
  });
 } //这里就是通过一个匿名内部类，没有就过就回滚

 上面描述的编程式事物管理；另外还有声明式事物管理(有分为使用xml配置声明事务，使用注解声明事务)

xml配置：

<!-- jdbc事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource" ref="dataSource"></property>
    </bean>
   
    <!-- 配置事务通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
     <tx:attributes> 
            <tx:method name="insert*" propagation="REQUIRED" /> 
            <tx:method name="update*" propagation="REQUIRED" /> 
            <tx:method name="edit*" propagation="REQUIRED" /> 
            <tx:method name="save*" propagation="REQUIRED" /> 
            <tx:method name="add*" propagation="REQUIRED" /> 
            <tx:method name="new*" propagation="REQUIRED" /> 
            <tx:method name="set*" propagation="REQUIRED" /> 
            <tx:method name="remove*" propagation="REQUIRED" /> 
            <tx:method name="delete*" propagation="REQUIRED" /> 
            <tx:method name="change*" propagation="REQUIRED" /> 
            <tx:method name="get*" propagation="REQUIRED" read-only="true" /> 
            <tx:method name="find*" propagation="REQUIRED" read-only="true" /> 
            <tx:method name="load*" propagation="REQUIRED" read-only="true" /> 
            <tx:method name="*" propagation="REQUIRED" read-only="true" /> 
        </tx:attributes> 
    </tx:advice>
   
    <!-- 配置事务切面 -->
    <aop:config>
     <!-- 配置切点 -->
     <aop:pointcut id="serviceMethod" expression="execution(* com.java1234.service.*.*(..))" />
     <!-- 配置事务通知 -->
     <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod"/>
    </aop:config>
   

注解： 

<!-- jdbc事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource" ref="dataSource"></property>
    </bean>
   
    <tx:annotation-driven transaction-manager="transactionManager"/>

   <!-- 自动加载构建bean --> 
    <context:component-scan base-package="com.java1234" /> //这样此包下的所有bean就可以用注解

 spring--doc文档连接http://spring.cndocs.tk/

http://wenku.baidu.com/link?url=pOTfRLWGk91H0ydqHbSymWlRU86G6WgvZqrtilWq06kwAfkEU9yG4KvvYuiKfDgYi6uaVQoUtUK26ON-H-gvin8DAnb45qrF1nhqUGxnxzy

连接数据库：jdbc.properties

1、Oracle

<context:property-placeholder location="jdbc.properties"/>

jdbc.driverClassName=oracle.jdbc.driver.OracleDriver
jdbc.url=jdbc:oracle:thin:@132.224.24.118:1521:jsfx
jdbc.username=sett_analyse
jdbc.password=g4el_yj_ha

2、MySql

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db_spring
jdbc.username=root
jdbc.password=123456

对于一个大型的web应用来说，可能 有多个xml配置文件，在启动spring容器时，可以通过一个string数组指定这些配置文件，spring还允许我们通过

<import>将多个配置文件引入到一个文件中，进行配置文件的集成，这样在启动spring容器时，只需要指定这个合并好的文件即可，如果在spring容器启动时2个配置

文件都在配置文件列表中，那么这2个配置文件的bean就可以互相引用。

定义一个Dao的bean，我们可以通过使用注解：Component("userDao")可以被spring容器识别，spring容器自动将pojo转换成容器管理的bean

除了Component以外，spring还提供了3个功能基本和它等效的注解：

他们分别对Dao Service Controller进行注解：

@Repository

@Service

@Controller

---只所以要增加这3个注解，是为了让标注类的用途更清晰，但你完全可以用Component代替者3个注解；

添加扫描：

<context:component-scan base-package="">

使用Autowired注解实现bean的依赖注入，此注解默认按照类型匹配的方式，在容器中查找匹配的bean，找不到抛异常，

使用@Qualifier指定注入bean的名称，如果容器有一个以上匹配的bean时，则可以通过这个注解指定

例如容器中有两个UserDao类型的bean，一个名为userDao 另一个是otherUserDao

对类方法进行注解：

@Autowired可以对变量已经方法的入参进行标注；如果入参有多个，自动选择匹配入参类型的bean，spring允许对方法入参标注

@Qualifier以指定注入bean的名称：

@Autowired

public void init(@Qualifier("userDao") UserDao userDao,LogDao logDao){

}

--一般情况下：在Spring容器中大部分的bean都是单实例的，所以一般无须通过@Repository@Service的value属性为bean指定名称

也无须使用@Qualifier按名称进行注入；

对集合类进行标注：

如果对类中集合类的变量或方法进行Autowired标注，spring会将容器中类型匹配的所有bean都自动注入进来，

对标准注解的支持：

Spring还支持JSR-250中定义的 注解Resource和JSR-330中定义的@Inject注解；这2种注解和@Autowired注解类似；

都是对类变量和方法入参提供自动注入的功能，

@Resource("car")

private void setCar(Car car){

}

这时如果注解@Resource未指定bean的名称，则可以通过属性的方法得到需要注入的bean名称；

可见 @Autowired默认是按照类型匹配注入bean  @Resource按照名称注入bean

而@Inject和@Autowired一样也是通过类型注入bean 只是没有require属性；

因此不管是@Resource还是@Inject其功能都是没有@Autowired丰富，因此除非必要，大可不必在乎这2个注解

通过注解@PostConstruct和@PreDestory注解，在spring中他们相当于init-method和destory-method属性的功能；

不过使用注解时可以在一个bean中定义多个；

普通的POJO只要标注@Configuration注解，就可以为spring容器提供Bean定义的 信息了；

每个标注@Bean的类方法都相当于提供一个bean的定义信息

使用基于java类的配置信息启动spring容器：

直接通过@Configuration注解的类启动spring容器：

spring提供了一个AnnotationConfigApplicationContext类，它能够直接通过标注@Configuration的类启动spring容器：

 //ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
  ApplicationContext ac = new AnnotationConfigApplicationContext(HelloWorld.class);//HelloWorld类用Configuration注解
  HelloWorld helloWorld=(HelloWorld)ac.getBean("helloWorld");//getBean的参数也可以写成HelloWorld.class
此外  AnnotationConfigApplicationContext还支持通过编码的方式加载多个Configuration类

ct.register(HelloWorld.class);