Spring[02.基础知识整理(下)]

Bean使用外部属性文件

• 在配置文件里配置 Bean 时, 有时需要在 Bean 的配置里混入系统部署的细节信息(例如: 文件路径, 数据源配置信息等). 而这些部署细节实际上需要和 Bean 配置相分离

• Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器, 这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中. 可以在 Bean 配置文件里使用形式为 ${var} 的变量, PropertyPlaceholderConfigurer 从属性文件里加载属性, 并使用这些属性来替换变量.

• xml context加载外部配置文件<context:property-placeholder location="">

Spel表达式

是一个支持运行时查询和操作对象图的强大的表达式语言

通过 SpEL 可以实现：

• 通过 bean 的 id 对 bean 进行引用
• 调用方法以及引用对象中的属性
• 计算表达式的值
• 正则表达式的匹配

案例

验证邮箱

^[_A-Za-z0-9-]+(\.[_A-Za-z0-9-]+)"+"*@[A-Za-z0-9]+(\.[A-Za-z0-9]+)*(\.[A-Za-z]{2,})$

Bean的生命周期

生命周期

• Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务.
• Spring IOC 容器对 Bean 的生命周期进行管理的过程:
  • 通过构造器或工厂方法创建 Bean 实例
  • 为 Bean 的属性设置值和对其他 Bean 的引用
  • 调用 Bean 的初始化方法
  • Bean 可以使用了
  • 当容器关闭时, 调用 Bean 的销毁方法
• 在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法.

Bean后置处理器

基本介绍

• Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
• Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例. 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
• 对Bean 后置处理器而言, 需要实现BeanPostProcessor接口.

在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口的以下两个方法:

public class MyBeanPostProcesser implements BeanPostProcessor { // 在init-method之前调用 @Override public Object postProcessBeforeInitialization(Object o, String s) throws BeansException { System.out.println("postProcessBeforeInitialization: " + s); return o; } // 在init-method之后调用 @Override public Object postProcessAfterInitialization(Object o, String s) throws BeansException { System.out.println("postProcessAfterInitialization: " + s); return o; } }

后置处理器特性

//Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
//Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例.
// 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.

//采用前置和后置处理之后
//首先运行构造函数
//然后给属性赋值
//然后访问前置处理函数
//然后访问init函数
//然后访问后置处理函数
//然后输出结果
//最后访问destroy函数

@Autowired 自动装配 Bean

• 构造器, 普通字段(即使是非 public), 一切具有参数的方法都可以应用@Authwired 注解
  默认情况下, 所有使用 @Authwired 注解的属性都需要被设置. 当 Spring 找不到匹配的 Bean 装配属性时, 会抛出异常, 若某一属性允许不被设置, 可以设置 @Authwired 注解的 required 属性为 false

• 默认情况下, 当 IOC 容器里存在多个类型兼容的 Bean 时, 通过类型的自动装配将无法工作. 此时可以在 @Qualifier 注解里提供 Bean 的名称. Spring 允许对方法的入参标注 @Qualifiter 已指定注入 Bean 的名称

• @Authwired 注解也可以应用在数组类型的属性上, 此时 Spring 将会把所有匹配的 Bean 进行自动装配.

• @Authwired 注解也可以应用在集合属性上, 此时 Spring 读取该集合的类型信息, 然后自动装配所有与之兼容的 Bean.

• @Authwired 注解用在 java.util.Map 上时, 若该 Map 的键值为 String, 那么 Spring 将自动装配与之 Map 值类型兼容的 Bean, 此时 Bean 的名称作为键值

AOP与AspectJ

概述

是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充.

AOP 的主要编程对象是切面(aspect), 而切面模块化横切关注点.

在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用, 并且不必修改受影响的类. 这样一来横切关注点就被模块化到特殊的对象(切面)里.

AOP 的好处:

• 每个事物逻辑位于一个位置, 代码不分散, 便于维护和升级
• 业务模块更简洁, 只包含核心业务代码.

术语

• 切面(Aspect): 横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象
• 通知(Advice): 切面必须要完成的工作
• 目标(Target): 被通知的对象
• 代理(Proxy): 向目标对象应用通知之后创建的对象
• 连接点（Joinpoint）：程序执行的某个特定位置：如类某个方法调用前、调用后、方法抛出异常后等。连接点由两个信息确定：方法表示的程序执行点；相对点表示的方位。例如 ArithmethicCalculator#add() 方法执行前的连接点，执行点为 ArithmethicCalculator#add()； 方位为该方法执行前的位置
• 切点（pointcut）：每个类都拥有多个连接点：例如 ArithmethicCalculator 的所有方法实际上都是连接点，即连接点是程序类中客观存在的事务。AOP 通过切点定位到特定的连接点。类比：连接点相当于数据库中的记录，切点相当于查询条件。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

AspectJ

AspectJ：Java 社区里最完整最流行的 AOP 框架.在 Spring2.0 以上版本中, 可以使用基于 AspectJ 注解或基于 XML 配置的 AOP

依赖包:

• aopalliance-1.0.jar
• aspectjrt.jar
• aspectjtools.jar
• aspectjweaver.jar
• org.aspectj.matcher.jar

AspectJ通知注解

• @Before: 前置通知, 在方法执行之前执行
• @After: 后置通知, 在方法执行之后执行
• @AfterRunning: 返回通知, 在方法返回结果之后执行
• @AfterThrowing: 异常通知, 在方法抛出异常之后

• @Around: 环绕通知, 围绕着方法执行

  切入点合并

• @Pointcut 将多个被限制的bean或者bean方法合并为一个集合,AspectJ通知注解可以直接调用合并切入点的方法,
  如: combinePointCut

  Order

• 制定切面的优先级
• 数字越小,代表优先级越高

案例

@Aspect @Order(0) public class AspectProcessor { // 合并切入点 @Pointcut("execution(* com.demo.aop.aspect.CalculatorImpl.*(..)))") public void combinePointCut(){} // 此函数在指定的bean方法执行前响应 // @Before("execution (* com.demo.aop.aspect.CalculatorImpl.*(..))") @Before("combinePointCut()") public void beforeAspectProcessor(JoinPoint joinPoint){ System.out.println("beforeAspectProcessor method name: " + joinPoint.getSignature().getName()); System.out.println("beforeAspectProcessor method args: " + Arrays.asList(joinPoint.getArgs())); } // 此函数在指定的bean方法执行后响应 // @After("execution (* com.demo.aop.aspect.CalculatorImpl.*(..))") @After("combinePointCut()") public void afterAspectProcessor(JoinPoint joinPoint){ System.out.println("afterAspectProcessor method name: " + joinPoint.getSignature().getName()); System.out.println("afterAspectProcessor method args: " + Arrays.asList(joinPoint.getArgs())); } // 此函数在指定的bean方法执行前、后响应 // @Around("combinePointCut()") // public void around(ProceedingJoinPoint pjp) throws Throwable{ // System.out.println("已经记录下操作日志@Around 方法执行前"); // pjp.proceed(); // System.out.println("已经记录下操作日志@Around 方法执行后"); // } // 如果只想在连接点返回的时候记录, 应使用返回通知代替后置通知 @AfterReturning(value = "combinePointCut()", returning = "result") public void afterReturningAspectProcessor(JoinPoint joinPoint, Object result){ System.out.println("afterReturningAspectProcessor method name: " + joinPoint.getSignature().getName()); System.out.println("afterReturningAspectProcessor method args: " + Arrays.asList(joinPoint.getArgs())); System.out.println("afterReturningAspectProcessor method result: " + result); } // 异常通知 @AfterThrowing(value = "combinePointCut()", throwing = "e") public void afterThrowingAspectProcessor(JoinPoint joinPoint, Exception e){ System.out.println("afterThrowingAspectProcessor method name: " + joinPoint.getSignature().getName()); System.out.println("afterThrowingAspectProcessor method args: " + Arrays.asList(joinPoint.getArgs())); System.out.println("afterThrowingAspectProcessor method throwing: " + e); } }

• 将 aop Schema 添加到 <beans> 根元素中.
• 要在 Spring IOC 容器中启用 AspectJ 注解支持, 只要在 Bean 配置文件中定义一个空的 XML 元素 <aop:aspectj-autoproxy>
• 当 Spring IOC 容器侦测到 Bean 配置文件中的 <aop:aspectj-autoproxy> 元素时, 会自动为与 AspectJ 切面匹配的 Bean 创建代理

<!--让aspectj @before @after注解生效-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<context:component-scan base-package="com.demo.aop.aspect"></context:component-scan>

通过代理方式实现AspectJ

import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Repository; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.Arrays; /** * Created by plusplusxu on 2017/10/23. * * 动态代理模式主要用来做方法的增强，让你可以在不修改源码的情况下，增强一些方法， * 在方法执行前后做任何你想做的事情（甚至根本不去执行这个方法）， * 因为在InvocationHandler的invoke方法中，你可以直接获取正在调用方法对应的Method对象， * 具体应用的话，比如可以添加调用日志，做事务控制等。 * 动态代理是设计模式当中代理模式的一种。 */ @Repository public class CalculatorImplProxy { @Autowired private Calculator target; public Calculator getProxy(){ Calculator proxy = null; // 代理对象由哪一个加载器加载 ClassLoader loader = target.getClass().getClassLoader(); // 代理对象的内容 Class[] interfaces = new Class[]{Calculator.class}; // 当调用代理对象的方法的时候,该方法被执行 InvocationHandler h = new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 代理对象方法执行前操作 System.out.println("method: " + method.getName() + " " + " args: " + Arrays.asList(args)); Object result = method.invoke(target, args); // 代理对象方法执行后操作 System.out.println("method: " + method.getName() + " " + " args: " + Arrays.asList(args) + " result: " + result); return result; } }; proxy = (Calculator)Proxy.newProxyInstance(loader, interfaces, h); return proxy; } } 

JDBC

JdbcTemplate

作为 Spring JDBC 框架的核心, JDBC 模板的设计目的是为不同类型的 JDBC 操作提供模板方法. 每个模板方法都能控制整个过程, 并允许覆盖过程中的特定任务. 通过这种方式, 可以在尽可能保留灵活性的情况下, 将数据库存取的工作量降到最低.

• 每次使用都创建一个 JdbcTemplate 的新实例, 这种做法效率很低下.
• JdbcTemplate 类被设计成为线程安全的, 所以可以再 IOC 容器中声明它的单个实例, 并将这个实例注入到所有的 DAO 实例中.
• JdbcTemplate 也利用了 Java 1.5 的特定(自动装箱, 泛型, 可变长度等)来简化开发

JdbcDaoSupport

该类声明了 jdbcTemplate 属性, 它可以从 IOC 容器中注入, 或者自动从数据源中创建.

package com.mysql; import org.springframework.jdbc.core.BatchPreparedStatementSetter; import org.springframework.jdbc.core.JdbcTemplate; import java.sql.PreparedStatement; import java.sql.SQLException; import java.util.List; /** * Created by plusplusxu on 2017/10/25. * * 操作mysql的数据类 * * JdbcTemplate 类被设计成为线程安全的, 所以可以再 IOC 容器中声明它的单个实例, 并将这个实例注入到所有的 DAO 实例中. */ public class ProjectDao { public ProjectDao(JdbcTemplate jdbcTemplateObject) { this.jdbcTemplateObject = jdbcTemplateObject; } public ProjectDao() { } public JdbcTemplate getJdbcTemplateObject() { return jdbcTemplateObject; } public void setJdbcTemplateObject(JdbcTemplate jdbcTemplateObject) { this.jdbcTemplateObject = jdbcTemplateObject; } // spring 提供的访问数据库的工具类,需要配置javax.sql.DataSource // 本例中在applicationContext中配置的mysql数据源 private JdbcTemplate jdbcTemplateObject; // 添加一条项目记录 // tbl_devops_project为vsdo数据库的项目表(Project) public void addproject(Project project) { String sql = "INSERT INTO tbl_devops_project(name,public,language,description," + "admin, members, gitlab_id,gitlab_url,code_styles,sonar_lint_server_url) " + "VALUES(?,?,?,?,?,?,?,?,?,?)"; try { jdbcTemplateObject.update(sql, project.getName(),project.getPub(),project.getLanguage(),project.getDescription(), project.getAdmin(),project.getMembers(),project.getGitlab_id(), project.getGitlab_url(),project.getCode_styles(),project.getSonar_lint_server_url()); } catch (Exception e){ System.out.println(e); } return ; } // 根据项目名删除记录 public void delprojectbyname(String name) { String sql = "DELETE FROM tbl_devops_project WHERE name=?"; try { jdbcTemplateObject.update(sql,name); } catch (Exception e){ System.out.println(e); } return ; } // 删除所有项目 public void delallproject() { String sql = "DELETE FROM tbl_devops_project"; try { jdbcTemplateObject.update(sql); } catch (Exception e){ System.out.println(e); } return ; } // 更新某个项目 public void updproject(Project project) { String sql = "UPDATE tbl_devops_project set description=? WHERE name=?"; try { jdbcTemplateObject.update(sql,project.getDescription(), project.getName()); } catch (Exception e){ System.out.println(e); } return ; } // 获取所有项目 public List<Project> allproject() { List<Project> projects = null; String sql = "SELECT * FROM tbl_devops_project"; try { // ProjectMapper 项目表的映射类 projects = jdbcTemplateObject.query(sql, new ProjectMapper()); } catch (Exception e){ System.out.println(e); } return projects; } // 查询项目名对应的记录 public List<Project> queryprojectbyname(String name) { List<Project> projects = null; String sql = "SELECT * FROM tbl_devops_project WHERE name=?"; try { projects = jdbcTemplateObject.query(sql, new Object[]{name}, new ProjectMapper()); } catch (Exception e){ System.out.println(e); } return projects; } // 打印所有项目 public void displayall(){ List<Project> projects = allproject(); for(Project s : projects){ System.out.println(s); } } // 批量插入 public void insertBatch(final List<Project> projects){ String sql = "INSERT INTO tbl_devops_project(name,public,language,description," + "admin, members, gitlab_id,gitlab_url,code_styles,sonar_lint_server_url) " + "VALUES(?,?,?,?,?,?,?,?,?,?)"; jdbcTemplateObject.batchUpdate(sql, new BatchPreparedStatementSetter() { @Override public void setValues(PreparedStatement ps, int i) throws SQLException { Project project = projects.get(i); ps.setString(1, project.getName()); ps.setBoolean(2, project.getPub()); ps.setString(3, project.getLanguage()); ps.setString(4, project.getDescription()); ps.setString(5, project.getAdmin()); ps.setString(6, project.getMembers()); ps.setInt(7, project.getGitlab_id()); ps.setString(8, project.getGitlab_url()); ps.setString(9, project.getCode_styles()); ps.setString(10, project.getSonar_lint_server_url()); } @Override public int getBatchSize() { return projects.size(); } }); } } 

package com.mysql; import org.springframework.jdbc.core.BatchPreparedStatementSetter; import org.springframework.jdbc.core.support.JdbcDaoSupport; import java.sql.PreparedStatement; import java.sql.SQLException; import java.util.List; /** * Created by plusplusxu on 2017/10/26. * * 继承于JdbcDaoSupport,直接封装了JdbcTemplate,写起来更方便 * * 该类声明了 jdbcTemplate 属性, 它可以从 IOC 容器中注入, 或者自动从数据源中创建. * */ public class JdbcDaoSupportImpl extends JdbcDaoSupport { // 添加一条项目记录 // tbl_devops_project为vsdo数据库的项目表(Project) public void addproject(Project project) { String sql = "INSERT INTO tbl_devops_project(name,public,language,description," + "admin, members, gitlab_id,gitlab_url,code_styles,sonar_lint_server_url) " + "VALUES(?,?,?,?,?,?,?,?,?,?)"; try { this.getJdbcTemplate().update(sql, project.getName(),project.getPub(),project.getLanguage(),project.getDescription(), project.getAdmin(),project.getMembers(),project.getGitlab_id(), project.getGitlab_url(),project.getCode_styles(),project.getSonar_lint_server_url()); } catch (Exception e){ System.out.println(e); } return ; } // 根据项目名删除记录 public void delprojectbyname(String name) { String sql = "DELETE FROM tbl_devops_project WHERE name=?"; try { this.getJdbcTemplate().update(sql,name); } catch (Exception e){ System.out.println(e); } return ; } // 删除所有项目 public void delallproject() { String sql = "DELETE FROM tbl_devops_project"; try { this.getJdbcTemplate().update(sql); } catch (Exception e){ System.out.println(e); } return ; } // 更新某个项目 public void updproject(Project project) { String sql = "UPDATE tbl_devops_project set description=? WHERE name=?"; try { this.getJdbcTemplate().update(sql,project.getDescription(), project.getName()); } catch (Exception e){ System.out.println(e); } return ; } // 获取所有项目 public List<Project> allproject() { List<Project> projects = null; String sql = "SELECT * FROM tbl_devops_project"; try { // ProjectMapper 项目表的映射类 projects = this.getJdbcTemplate().query(sql, new ProjectMapper()); } catch (Exception e){ System.out.println(e); } return projects; } // 查询项目名对应的记录 public List<Project> queryprojectbyname(String name) { List<Project> projects = null; String sql = "SELECT * FROM tbl_devops_project WHERE name=?"; try { projects = this.getJdbcTemplate().query(sql, new Object[]{name}, new ProjectMapper()); } catch (Exception e){ System.out.println(e); } return projects; } // 打印所有项目 public void displayall(){ List<Project> projects = allproject(); for(Project s : projects){ System.out.println(s); } } // 批量插入 public void insertBatch(final List<Project> projects){ String sql = "INSERT INTO tbl_devops_project(name,public,language,description," + "admin, members, gitlab_id,gitlab_url,code_styles,sonar_lint_server_url) " + "VALUES(?,?,?,?,?,?,?,?,?,?)"; this.getJdbcTemplate().batchUpdate(sql, new BatchPreparedStatementSetter() { @Override public void setValues(PreparedStatement ps, int i) throws SQLException { Project project = projects.get(i); ps.setString(1, project.getName()); ps.setBoolean(2, project.getPub()); ps.setString(3, project.getLanguage()); ps.setString(4, project.getDescription()); ps.setString(5, project.getAdmin()); ps.setString(6, project.getMembers()); ps.setInt(7, project.getGitlab_id()); ps.setString(8, project.getGitlab_url()); ps.setString(9, project.getCode_styles()); ps.setString(10, project.getSonar_lint_server_url()); } @Override public int getBatchSize() { return projects.size(); } }); } } 

<?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原生的DriverManagerDataSource和mysql驱动配置数据源--> <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver" /> <!--注意一下&characterEncoding要修改为&characterEncoding--> <!--vsdo为mysql数据库名称--> <property name="url" value="jdbc:mysql://localhost:3306/vsdo?useUnicode=true&characterEncoding=utf-8"/> <property name="username" value="root"/> <property name="password" value="123456" /> </bean> <!----> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <!--配置数据源依赖--> <property name="dataSource" ref="datasource" /> </bean> <bean id="projectDaoImp" class="com.mysql.ProjectDao"> <!--添加jdbc访问类依赖--> <property name="jdbcTemplateObject" ref="jdbcTemplate"></property> </bean> <bean id="jdbcDaoSupportImpl" class="com.mysql.JdbcDaoSupportImpl"> <property name="dataSource" ref="datasource"></property> </bean> </beans>

事务

事务管理是企业级应用程序开发中必不可少的技术, 用来确保数据的完整性和一致性.

事务就是一系列的动作, 它们被当做一个单独的工作单元. 这些动作要么全部完成, 要么全部不起作用

事务的四个关键属性(ACID)

• 原子性(atomicity): 事务是一个原子操作, 由一系列动作组成. 事务的原子性确保动作要么全部完成要么完全不起作用.
• 一致性(consistency): 一旦所有事务动作完成, 事务就被提交. 数据和资源就处于一种满足业务规则的一致性状态中.
• 隔离性(isolation): 可能有许多事务会同时处理相同的数据, 因此每个事物都应该与其他事务隔离开来, 防止数据损坏.
• 持久性(durability): 一旦事务完成, 无论发生什么系统错误, 它的结果都不应该受到影响. 通常情况下, 事务的结果被写到持久化存储器中.

Spring 既支持编程式事务管理, 也支持声明式的事务管理.

• 编程式事务管理: 将事务管理代码嵌入到业务方法中来控制事务的提交和回滚. 在编程式管理事务时, 必须在每个事务操作中包含额外的事务管理代码.
• 声明式事务管理: 大多数情况下比编程式事务管理更好用. 它将事务管理代码从业务方法中分离出来, 以声明的方式来实现事务管理. 事务管理作为一种横切关注点, 可以通过 AOP 方法模块化. Spring 通过 Spring AOP 框架支持声明式事务管理.

用 @Transactional 注解声明式地管理事务

Spring 还允许简单地用 @Transactional 注解来标注事务方法.

• 为了将方法定义为支持事务处理的, 可以为方法添加 @Transactional 注解. 根据 Spring AOP 基于代理机制, 只能标注公有方法.

• 可以在方法或者类级别上添加 @Transactional 注解. 当把这个注解应用到类上时, 这个类中的所有公共方法都会被定义成支持事务处理的.
• 在 Bean 配置文件中只需要启用 <tx:annotation-driven> 元素, 并为之指定事务管理器就可以了.
• 如果事务处理器的名称是 transactionManager, 就可以在<tx:annotation-driven> 元素中省略 transaction-manager 属性. 这个元素会自动检测该名称的事务处理器.

事务的传播行为

当事务方法被另一个事务方法调用时, 必须指定事务应该如何传播. 例如: 方法可能继续在现有事务中运行, 也可能开启一个新事务, 并在自己的事务中运行.