spring学习笔记

控制反转（IOC）：就是应用本身不负责依赖对象的创建和维护，依赖对象的创建及维护是由外部容器负责的，这样控制权就由应用转移到了外部容器，即控制权的转移就是控制反转。

依赖注入（DI）：在程序运行期间，由外部容器动态地将依赖对象注入到组件中。主要通过构造函数或者setter来具体实现。

ClassPathXmlApplicationContext

FileSystemXmlApplicationContext

静态工厂：类名.静态方法（）

实例工厂：先创建工厂实例，然后调用工厂实例的方法 factory-bean：表示具体工厂类的实例 factory-method：表示具体工厂实例的方法

FactoryBean是Spring规定的一个接口，对于FactoryBean接口的实现类，Spring 都会将其作为一个工厂，但是在ioc容器启动的时候不会创建实例， 只有在使用的时候才会创建对象。此方式是spring创建bean方式的一种补充， 用户可以按照需求创建对象，创建的对象交由spring IOC容器来进行管理，无论是否是单例， 都是在用到的时候才会创建该对象，不用该对象不会创建。 使用方法： 1、实现FactoryBean接口 2、将实现类交给IOC容器去管理

配置文件中： <bean id="person" class="com.fan.bean.Person" > <property name="id" value="1"></property> <property name="name" value="zhangsan"></property> </bean> 实体类中： public void setId(int id) { this.id = id; } public void setName(String name) { this.name = name; }

name：表示参数列表的名称 value：表示实际的具体值 type：表示值的类型 index：表示值的下标，从0开始

xml配置文件中： <bean id="person2" class="com.fan.bean.Person"> <constructor-arg name="id" value="2"></constructor-arg> <constructor-arg name="name" value="tom"></constructor-arg> <constructor-arg name="age" value="22"></constructor-arg> <constructor-arg name="gender" value="男"></constructor-arg> </bean> 实体类中： public Person(int id, String name, Integer age, String gender) { this.id = id; this.name = name; this.age = age; this.gender = gender; }

当通过构造器方法赋值的时候，name属性可以省略不写，但要注意value的赋值顺序要和构造方法参数列表一致

可以加index来保证顺序的正确

当有多个相同参数个数的构造方法存在的时候，默认情况下是覆盖的过程，后面的构造方法会覆盖前面的构造方法，如果非要赋值给另外一个构造方法的话，，可以使用type参数来指定类型

xmlns:p="http://www.springframework.org/schema/p" <bean id="person6" class="com.fan.bean.Person" p:id="5" p:name="wangwu" p:age="25" p:gender="女"> </bean>

<!--给数组赋值, 使用array标签--> <!--<property name="hobbies" value="book,sport,movie"></property>--> <property name="hobbies"> <array> <value>book</value> <value>movie</value> <value>sport</value> </array> </property>

<!--给引用类型赋值, 可以使用ref引入外部bean--> <property name="address" ref="address"></property>

<!--给list赋值--> <!--<property name="lists" value="1,2,3"></property>--> <property name="lists"> <list> <!--使用内部bean，无法从IOC容器中直接获取对象的值--> <bean class="com.fan.bean.Address"> <property name="province" value="北京"></property> </bean> <bean class="com.fan.bean.Address"> <property name="province" value="上海"></property> </bean> <!--使用外部bean，可以随意从IOC容器中获取对象的值--> <ref bean="address"></ref> </list> </property>

<!--给set属性赋值--> <property name="sets"> <set> <value>zhangsan</value> <value>zhangsan</value> <value>wangwu</value> </set> </property>

<!--给map赋值--> <property name="maps"> <map> <entry key="a" value="aaa"></entry> <entry key="address" value-ref="address"></entry> <entry key="address2"> <bean class="com.fan.bean.Address"> <property name="province" value="广东省"></property> </bean> </entry> <entry> <key> <value>hehe</value> </key> <value>haha</value> </entry> <entry key="list"> <list> <value>11</value> <value>22</value> </list> </entry> </map> </property>

<!--给properties赋值--> <property name="properties"> <props> <prop key="111">aaa</prop> <prop key="222">bbb</prop> </props> </property>

<!--bean之间的继承关系. 可以使用abstract标签定义抽象bean，为true时无法进行实例化--> <bean id="parent" class="com.fan.bean.Person" abstract="false"> <property name="id" value="1"></property> <property name="name" value="zhangsan"></property> <property name="age" value="20"></property> <property name="gender" value="男"></property> </bean> <!--可以通过parent属性来获取父bean中的某些属性值--> <bean id="son" class="com.fan.bean.Person" parent="parent"> <property name="name" value="haha"></property> </bean>

//实体类中定义普通的方法 public void init(){ //编写N行逻辑代码完成初始化功能 System.out.println("person对象初始化完成"); } public void destory(){ System.out.println("person对象被销毁"); } <bean id="person12" class="com.fan.bean.Person" init-method="init" destroy-method="destory"></bean>

public class MyBeanPostProcessor implements BeanPostProcessor { /** * 在每一个对象的初始化方法之前执行 * @param bean 表示创建的具体对象 * @param beanName 表示bean的id属性 * @return * @throws BeansException */ public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("postProcessBeforeInitialization:" + beanName); return bean; } /** * 在每一对象的初始化方法后面执行 * @param bean * @param beanName * @return * @throws BeansException */ public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("postProcessAfterInitialization:" + beanName); return bean; } } <bean id="myBeanPostProcessor" class="com.fan.bean.MyBeanPostProcessor"></bean>

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" xmlns:context="http://www.springframework.org/schema/context" 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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!--开启包的扫描--> <context:component-scan base-package="com.fan"></context:component-scan> <!--开启AOP的注解功能--> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> </beans>

切面类： package com.fan.util; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.Signature; import org.aspectj.lang.annotation.*; import org.springframework.core.annotation.Order; import org.springframework.stereotype.Component; import java.util.Arrays; @Aspect @Component //保证能被ioc容器扫描到该类 @Order(200) //决定切面的执行顺序，默认是按照切面类的首字母排序执行 public class LogUtil { //相同的表达式可以使用切入点抽象成一个方法供其他通知方法引用 @Pointcut("execution(public Integer com.fan.service.MyCalculator.*(..))") public void myPointCut(){} @Pointcut("execution(* *(..))") public void myPointCut1(){} //@Before(value = "execution(public Integer com.fan.service.MyCalculator.*(..))") @Before(value = "myPointCut()") //前置通知，在方法执行之前完成 public static void start(JoinPoint joinPoint){ //获取方法签名 Signature signature = joinPoint.getSignature(); //获取方法参数信息 Object[] args = joinPoint.getArgs(); System.out.println("Log---" + signature.getName() + "方法开始执行：参数是" + Arrays.asList(args) ); } //@AfterReturning(value = "execution(public Integer com.fan.service.MyCalculator.*(..))", returning = "result") @AfterReturning(value = "myPointCut()", returning = "result") //返回通知，在返回结果之后执行 public static void stop(JoinPoint joinPoint, Object result) { Signature signature = joinPoint.getSignature(); System.out.println("Log---" + signature.getName() + "方法执行结束：结果是：" + result); } //@AfterThrowing(value = "execution(public Integer com.fan.service.MyCalculator.*(..))", throwing = "e") @AfterThrowing(value = "myPointCut()", throwing = "e") //异常通知，出现异常的时候执行 public static void logException(JoinPoint joinPoint, Exception e){ Signature signature = joinPoint.getSignature(); System.out.println("Log---" + signature.getName() + "抛出异常:" + e.getMessage()); } //@After("execution(public Integer com.fan.service.MyCalculator.*(..))") @After("myPointCut()") //后置通知，在方法执行完成之后执行 public static void logFinally(JoinPoint joinPoint){ Signature signature = joinPoint.getSignature(); System.out.println("Log---" + signature.getName() + "方法执行结束..."); } @Around("myPointCut()") //环绕通知，更细粒度的通知方式 public Object around(ProceedingJoinPoint pjp) throws Throwable { Signature signature = pjp.getSignature(); Object[] args = pjp.getArgs(); Object result = null; try { System.out.println("Log---" + "环绕通知start：" + signature.getName() + "方法开始执行，参数为：" + Arrays.asList(args)); //通过反射的方式调用目标方法(可以自己修改结果值)，相当于jdk中代理的method.invoke() result = pjp.proceed(args); System.out.println("Log---" + "环绕通知stop：" + signature.getName()); } catch (Throwable throwable) { System.out.println("Log---" + "环绕通知异常：" + signature.getName()); //出现异常的时候，在环绕通知中解决了，那么普通通知是接收不到的，如果想让普通通知接收到需要进行异常抛出 throw throwable; }finally { System.out.println("Log---" + "环绕通知返回：" + signature.getName() + "方法返回结果是：" + result); } return result; } }

以上切面类中需要注意： + 通知的执行顺序： 如果正常执行：@Before-->@After-->@AfterReturning 如果异常执行：@Before-->@After-->@AfterThrowing + 切入点表达式： 最精确的匹配方式： public Integer com.fan.service.MyCalculator.add(Integer, Integer) 在实际生产环境中，更多的时候使用通配符的方式 一、 1、可以用来匹配一个或者多个字符，如public Integer com.fan.service.MyCalculator.*(Integer, Integer)，匹配参数满足参数列表的多个方法 2、匹配任意类型的参数，如public Integer com.fan.service.M*Calculator.*(Integer, *) 3、在匹配时一个*只能匹配一层路径，要想匹配多层，如两层路径，可以使用两个*，public Integer com.fan.\*.\*.MyCalculator.add(Integer, Integer) 4、不能匹配访问修饰符，如果不确定访问修饰符是什么，可以直接省略不写，如 Integer com.fan.service.MyCalculator.add(Integer, Integer) 5、返回值可以使用\*来代替，public * com.fan.service.MyCalculator.add(Integer, Integer) 二、 1、可以匹配任意类型的多个参数，如execution(* com.fan.service.MyCalculator.\*(..)) 2、可以匹配多层路径，如execution(* com.fan..MyCalculator.\*(..) 最偷懒的方式： execution(\* \*(..))，第一个*代表返回值类型，第二个*代表所有路径 execution(* com..\*(..)) execution(* \*.\*(..)) 如果表达式是以*开头，那么可以代替所有路径 在使用表达式的时候还支持逻辑运算： &&：多个条件必须同时满足 execution(public Integer com.fan.service.MyCalculator.\*(..)) && execution(\* *(..)) ||：多个条件只要满足其中一个即可 execution(public Integer com.fan.service.MyCalculator.\*(..)) || execution(\* *(..)) !：取反，除了该种情况外其他都满足 !execution(public Integer com.fan.service.MyCalculator.add(..)) + 如果想要获取被代理类方法的参数或者方法名称等信息，必须使用JoinPoint对象，并且该对象作为方法参数必须在参数列表中第一个位置 getSignature() getArgs() + 如果方法中有返回值，那么必须要在注解中添加Returning=“带有返回值的参数”，该参数必须要和参数列表中的参数名称保持一致 如果需要添加异常信息，那么在注解中要添加Throwing=“异常参数”，该参数必须要和参数列表中参数名称保持一致 + 如果想要添加其他参数，必须要添加args(参数列表)，ArgNames(参数列表)： value = "execution(public Integer com.fan.service.MyCalculator.*(..)) && args(joinPoint,i)", argNames = "joinPoint,i" + 通知方法在定义的时候对于方法的修饰符、返回值类型都没有明确的要求， 但是要注意，方法的参数不能随便添加 + 环绕通知： 环绕通知在执行的时候优先于普通通知， 如果是正常结束，那么执行顺序是： 环绕前置通知-->@Before-->环绕后置通知-->环绕返回通知-->@After-->@AfterReturning 如果是异常结束，那么执行顺序是： 环绕前置通知-->@Before-->环绕异常通知-->环绕返回通知-->@After-->@AfterReturning 出现异常的时候，在环绕通知中解决了，那么普通通知是接收不到的，如果想让普通通知接收到需要进行异常抛出 throw throwable，此时执行顺序为： 环绕前置通知--》@Before--》环绕异常通知--》环绕返回通知--》@After--》@AfterThrowing 当应用程序包含多个切面类的时候，按照切面类的名称的首字母进行排序后执行，如果需要人为规定执行顺序，可有在切面类上添加@Order注解，同时可以添加具体的值，值越小，越优先。

需要被以上切面类增强的类： package com.fan.service; import org.springframework.stereotype.Service; @Service public class MyCalculator /*implements Calculator*/{ public Integer add(Integer i, Integer j) throws NoSuchMethodException { Integer result = i + j; return result; } public Integer sub(Integer i, Integer j) throws NoSuchMethodException { Integer result = i - j; return result; } public Integer mul(Integer i, Integer j) throws NoSuchMethodException { Integer result = i * j; return result; } public Integer div(Integer i, Integer j) throws NoSuchMethodException { Integer result = i / j; return result; } }

用到的jar包：spring-context、cglib、aspectjrt、aopalliance、spring-aspects、druid、mysql-connector-java、spring-jdbc

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" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <context:component-scan base-package="com.fan"></context:component-scan> <!--加载数据库配置文件--> <context:property-placeholder location="classpath:db.properties"></context:property-placeholder> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="username" value="${jdbc.username}"></property> <property name="password" value="${jdbc.password}"></property> <property name="url" value="${jdbc.url}"></property> <property name="driverClassName" value="${jdbc.driverName}"></property> </bean> <!--JdbcTemplate相当于增删改查模板--> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"></property> </bean> <!--配置事务管理器的bean对象--> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean> <!--开启基于注解的事务管理器的配置--> <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven> </beans>

事务类： package com.fan.service; import com.fan.dao.BookDao; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Isolation; import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import java.io.File; import java.io.FileNotFoundException; @Service public class BookService { @Autowired private BookDao bookDao; //@Transactional(timeout = 3) //@Transactional(readOnly = true) //@Transactional(noRollbackFor = {ArithmeticException.class}) //@Transactional(noRollbackForClassName = {"java.lang.ArithmeticException"}) //@Transactional(rollbackFor = {FileNotFoundException.class}) //@Transactional(rollbackForClassName = {"java.io.FileNotFoundException"}) @Transactional(propagation = Propagation.NESTED) public void buyBook() { bookDao.getPrice(1); bookDao.updateBalance("zhangsan", 100); bookDao.updateStock(1); int i = 1/0; //timeout 超时时间测试 //Thread.sleep(3000); //异常不回滚测试:noRollbackFor = {ArithmeticException.class} //int i = 1/0; //1、如果使用try catch把异常int i = 1/0;捕捉处理后，代码仍然可以继续往下执行，此时事务@Transactional //不再起作用 /*try { int i = 1/0; } catch (Exception e) { e.printStackTrace(); }*/ //2、遇到异常int i = 1/0;直接执行catch处理异常，然后结束，不会执行bookDao.updateStock(1); //事务@Transactional不会起作用 /*try{ bookDao.getPrice(1); bookDao.updateBalance("zhangsan", 100); int i = 1/0; bookDao.updateStock(1); }catch(Exception e){ e.printStackTrace(); }*/ //异常回滚测试：rollbackFor = {FileNotFoundException.class} //new File("a.txt"); } @Transactional public void updatePrice(){ bookDao.updatePrice(1); } }

以上事务类中需要注意： * @Transactional(propagation = Propagation.XXX)注解中的值： propagation:传播特性：表示不同的事务之间执行的关系，调用事务方法的事务方法与当前事务方法在不同的类中时才有事务传播特性，如果是在同一个类中，则被认为是同一个事务，不再具备AOP的事务传播特性。 spring的事务传播行为共有7种：(以下当前方法是指被事务注解Transactional()标记的方法) 1、REQUIRED：如果有事务在运行，当前的方法(被调用的事务方法)就在这个事务内运行，否则就启动一个新的事务，并在自己的事务内运行 如果当前方法有异常，即使在调用当前方法的方法（事务方法）中将当前方法的异常进行try catch，那么调用当前方法的方法中的其他代码仍然会进行回滚。 如果调用当前方法的事务方法中有异常或者调用当前方法的事务方法中调用的其他方法有异常，那么当前方法会进行回滚。 总结：REQUIRED事务方法依赖于外部事务方法，无论是当前事务方法还是调用当前事务方法的事务方法，只要任意一个事务方法中有异常，那么全部事务方法都将进行回滚。 2、REQUIRES_NEW：当前的方法启动新事务（这种事务是独立的，与调用当前方法的方法是否有事务无关），并在它自己的事务内运行，如果有事务正在运行，应该将他挂起（暂停）。 如果当前方法有异常，并且在调用当前方法的方法（事务方法）中将当前方法的异常进行try catch捕获处理，那么调用当前方法的方法中的其他代码不会进行回滚，而只对当前方法的代码进行回滚。也就是说，REQUIRES_NEW启动一个独立的新事务，该事务不会影响其他事务并且也不会受其他事务的影响。 如果调用当前方法的方法中有异常，那么当前方法不会进行回滚，因为当前方法是一个独立的新事务且没有异常，无需进行回滚。 总结：REQUIRES_NEW事务方法不依赖于外部事务方法，只有当前事务方法中有异常才会进行回滚。 3、SUPPORTS：如果有事务在运行，当前的方法就在这个事务内运行，否则它不运行在事务中 4、NOT_SUPPORTED：当前的方法不应该运行在事务中，如果有运行的事务，将他挂起，直到当前方法执行完毕 5、NEVER：当前的方法不应该运行在事务中，如果有运行的事务，就抛出异常（即当前方法不会正常执行） 6、MANDATORY：当前的方法必须运行在事务内，如果没有正在运行的事务，就抛出异常（即当前方法不会正常执行） 7、NESTED：如果有事务在运行，当前的方法就应该在这个事务的嵌套事务（被调用的子事务方法，包括当前方法）内运行，否则，就启动一个新的事务，并在它自己的事务内运行. 如果当前方法有异常，并且在调用当前方法的方法（事务方法）中将当前方法的异常进行try catch捕获处理，那么调用当前方法的方法中的其他事务方法代码不会进行回滚，而只对当前方法的代码进行回滚，这与REQUIRES_NEW相同。 如果调用当前方法的方法中有异常且没有进行try catch异常捕获处理，那么全部事务方法将进行回滚，这与REQUIRES_NEW刚好相反。 也就是说NESTED事务方法除了于自身有关外与调用当前方法的事务方法也是有关系的，只要调用当前方法的事务方法中有异常或者调用当前方法的事务方法中调用的其他方法有异常，那么当前方法就会进行回滚。 总结：NESTED事务方法有异常，那么NESTED事务方法将进行回滚。调用NESTED事务方法的事务方法有异常，那么全部事务方法将进行回滚。 * timeout:超时时间，单位为秒，超过该时间就会进行回滚 * readonly:只读事务：如果配置了只读事务，那么在事务运行期间，不允许对数据进行修改，否则抛出异常 * 设置哪些异常发生时事务不进行回滚：两者除了参数形式不同外，功能相同 noRollBackFor: 如：noRollbackFor = {ArithmeticException.class} noRollBackForClassName: 如：noRollbackForClassName = {"java.lang.ArithmeticException"} * 设置哪些异常发生时进行事务回滚： rollBackFor: 如：rollbackFor = {FileNotFoundException.class} rollbackForClassName: 如：rollbackForClassName = {"java.io.FileNotFoundException"}

DAO层类使用spring-jdbc提供的JdbcTemplate来操作数据库： package com.fan.dao; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Repository; @Repository public class BookDao { @Autowired private JdbcTemplate jdbcTemplate; /** * 减去某个用户的余额 * @param userName * @param price */ public void updateBalance(String userName, int price){ String sql = "update account set balance=balance-? where username=?"; jdbcTemplate.update(sql, price, userName); } /** * 通过图书id获取图书价格 * @param id * @return */ public int getPrice(int id){ String sql = "select price from book where id=?"; return jdbcTemplate.queryForObject(sql,Integer.class,id); } /** * 更改某本书的库存 * @param id */ public void updateStock(int id){ String sql = "update book_stock set stock=stock-1 where id=?"; jdbcTemplate.update(sql, id); } /** * 更新价格 * @param id */ public void updatePrice(int id){ String sql = "update book set price=price-1 where id=?"; jdbcTemplate.update(sql, id); } }

<?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:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <context:component-scan base-package="com.fan"></context:component-scan> <context:property-placeholder location="classpath:db.properties"></context:property-placeholder> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="username" value="${jdbc.username}"></property> <property name="password" value="${jdbc.password}"></property> <property name="url" value="${jdbc.url}"></property> <property name="driverClassName" value="${jdbc.driverName}"></property> </bean> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"></property> </bean> <!--事务的配置--> <!--声明一个事务管理器--> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean> <aop:config> <aop:pointcut id="exPointcut" expression="execution(* com.fan.service.*.*(..))"/> <!--事务建议--> <aop:advisor advice-ref="myAdvice" pointcut-ref="exPointcut"></aop:advisor> </aop:config> <tx:advice id="myAdvice" transaction-manager="transactionManager" > <!--配置事务的属性--> <tx:attributes> <!--配置在哪些方法上添加事务以及事务的传播特性--> <tx:method name="addBook" propagation="REQUIRED" read-only="true"/> <tx:method name="updatePrice" propagation="REQUIRED"></tx:method> <!--方法名称支持通配符--> <!-- <tx:method name="*" propagation="REQUIRED"></tx:method> --> </tx:attributes> </tx:advice> </beans>