Spring是一个开源框架,Spring是于2003年兴起的一个轻量级的Java开发框架,由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为J2EE应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。Spring的核心是控制反转(IoC)和面向切面(AOP)。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。
为什么说Spring是一个一站式的轻量级开源框架呢?EE开发可分成三层架构,针对JavaEE的三层结构,每一层Spring都提供了不同的解决技术。
从上面的简要介绍中,我们要知道Spring的核心有两部分:
AOP: Aspect Oriented Programming 面向切面编程。
面向切面编程(也叫面向方面):Aspect Oriented Programming(AOP),是目前软件开发中的一个热点。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
AOP是OOP的延续,是(Aspect Oriented Programming)的缩写,意思是面向切面(方面)编程。
主要的功能是:日志记录,性能统计,安全控制,事务处理,异常处理等等。
主要的意图是:将日志记录,性能统计,安全控制,事务处理,异常处理等代码从业务逻辑代码中划分出来,通过对这些行为的分离,我们希望可以将它们独立到非指导业务逻辑的方法中,进而改 变这些行为的时候不影响业务逻辑的代码。
可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续,设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,AOP可以说也是这种目标的一种实现。
假设把应用程序想成一个立体结构的话,OOP的利刃是纵向切入系统,把系统划分为很多个模块(如:用户模块,文章模块等等),而AOP的利刃是横向切入系统,提取各个模块可能都要重复操作的部分(如:权限检查,日志记录等等)。由此可见,AOP是OOP的一个有效补充。
注意:AOP不是一种技术,实际上是编程思想。凡是符合AOP思想的技术,都可以看成是AOP的实现。
Aop, aspect object programming 面向切面编程功能: 让关注点代码与业务代码分离!
关注点,重复代码就叫做关注点;
关注点形成的类,就叫切面(类)!
面向切面编程,就是指 对很多功能都有的重复的代码抽取,再在运行的时候网业务方法上动态植入“切面类代码”。
执行目标对象方法,动态植入切面代码。
可以通过切入点表达式,指定拦截哪些类的哪些方法; 给指定的类在运行的时候植入切面类代码。
通过代理控制对象的访问,可以详细访问某个对象的方法,在这个方法调用处理,或调用后处理。既(AOP微实现) ,AOP核心技术面向切面编程。
SpringAOP、事物原理、日志打印、权限控制、远程调用、安全代理 可以隐蔽真实角色
由程序员创建或工具生成代理类的源码,再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件,代理类和委托类的关系在运行前就确定了。
静态代理代码
public interface IUserDao {
void save();
}
public class UserDao implements IUserDao {
public void save() {
System.out.println("已经保存数据...");
}
}
代理类
public class UserDaoProxy implements IUserDao {
private IUserDao target;
public UserDaoProxy(IUserDao iuserDao) {
this.target = iuserDao;
}
public void save() {
System.out.println("开启事物...");
target.save();
System.out.println("关闭事物...");
}
}
缺点:jdk动态代理,必须是面向接口,目标业务类必须实现接口
// 每次生成动态代理类对象时,实现了InvocationHandler接口的调用处理器对象
public class InvocationHandlerImpl implements InvocationHandler {
private Object target;// 这其实业务实现类对象,用来调用具体的业务方法
// 通过构造函数传入目标对象
public InvocationHandlerImpl(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
System.out.println("调用开始处理");
result = method.invoke(target, args);
System.out.println("调用结束处理");
return result;
}
public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException,
IllegalAccessException, IllegalArgumentException, InvocationTargetException {
// 被代理对象
IUserDao userDao = new UserDao();
InvocationHandlerImpl invocationHandlerImpl = new InvocationHandlerImpl(userDao);
ClassLoader loader = userDao.getClass().getClassLoader();
Class[] interfaces = userDao.getClass().getInterfaces();
// 主要装载器、一组接口及调用处理动态代理实例
IUserDao newProxyInstance = (IUserDao) Proxy.newProxyInstance(loader, interfaces, invocationHandlerImpl);
newProxyInstance.save();
}
}
原理:利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。
使用cglib[Code Generation Library]实现动态代理,并不要求委托类必须实现接口,底层采用asm字节码生成框架生成代理类的字节码
CGLIB动态代理相关代码:
public class CglibProxy implements MethodInterceptor {
private Object targetObject;
// 这里的目标类型为Object,则可以接受任意一种参数作为被代理类,实现了动态代理
public Object getInstance(Object target) {
// 设置需要创建子类的类
this.targetObject = target;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(this);
return enhancer.create();
}
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("开启事物");
Object result = proxy.invoke(targetObject, args);
System.out.println("关闭事物");
// 返回代理对象
return result;
}
public static void main(String[] args) {
CglibProxy cglibProxy = new CglibProxy();
UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDao());
userDao.save();
}
}
java动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。而cglib动态代理是利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。Spring中。
JDK动态代理只能对实现了接口的类生成代理,而不能针对类 。CGLIB是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法 。因为是继承,所以该类或方法最好不要声明成final ,final可以阻止继承和多态。
spring.xml
常见用法
@Aspect 指定一个类为切面类
@Pointcut("execution(* com.itmayiedu.service.UserService.add(..))") 指定切入点表达式
@Before("pointCut_()") 前置通知: 目标方法之前执行
@After("pointCut_()") 后置通知:目标方法之后执行(始终执行)
@AfterReturning("pointCut_()") 返回后通知: 执行方法结束前执行(异常不执行)
@AfterThrowing("pointCut_()") 异常通知: 出现异常时候执行
@Around("pointCut_()") 环绕通知: 环绕目标方法执行
简单示例
// 切面类
@Component
@Aspect
public class AopLog {
// aop 编程中有几个通知: 前置通知 后置通知 运行通知 异常通知 环绕通知
@Before("execution(* com.codeobj.service.UserServices.add(..))")
public void before(){
System.out.println("前置通知 在方法之前执行");
}
@After("execution(* com.codeobj.service.UserServices.add(..))")
public void after(){
System.out.println("后置通知 在方法执行后执行");
}
@AfterReturning("execution(* com.codeobj.service.UserServices.add(..))")
public void returning(){
System.out.println("运行通知");
}
@AfterThrowing("execution(* com.codeobj.service.UserServices.add(..))")
public void afterThrowing(){
System.out.println("异常通知");
}
// 环绕通知在方法之前和之后处理事务
@Around("execution(* com.codeobj.service.UserServices.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
// 调用方法之前执行
System.out.println("环绕通知 调用方法之前执行");
proceedingJoinPoint.proceed(); //代理调用方法 注意点:如果调用方法抛出异常,不会执行后面的代码
System.out.println("环绕通知 调用方法之后执行");
// 调用方法之后执行
}
}
Xml实现aop编程:
1) 引入jar文件 【aop 相关jar, 4个】
2) 引入aop名称空间
3)aop 配置
* 配置切面类 (重复执行代码形成的类)
* aop配置
拦截哪些方法 / 拦截到方法后应用通知代码
public class AopLog2 {
// 前置通知
public void begin() {
System.out.println("前置通知");
}
//
// 后置通知
public void commit() {
System.out.println("后置通知");
}
// 运行通知
public void returning() {
System.out.println("运行通知");
}
// 异常通知
public void afterThrowing() {
System.out.println("异常通知");
}
// 环绕通知
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕通知开始");
proceedingJoinPoint.proceed();
System.out.println("环绕通知结束");
}
}
日志记录,性能统计,安全控制,事务处理,异常处理
自己手动控制事务,就叫做编程式事务控制。Jdbc代码:Conn.setAutoCommite(false); // 设置手动控制事务Hibernate代码:Session.beginTransaction(); // 开启一个事务【细粒度的事务控制: 可以对指定的方法、指定的方法的某几行添加事务控制】(比较灵活,但开发起来比较繁琐: 每次都要开启、提交、回滚.)
Spring提供了对事务的管理, 这个就叫声明式事务管理。Spring提供了对事务控制的实现。用户如果想用Spring的声明式事务管理,只需要在配置文件中配置即可; 不想使用时直接移除配置。这个实现了对事务控制的最大程度的解耦。Spring声明式事务管理,核心实现就是基于Aop。【粗粒度的事务控制: 只能给整个方法应用事务,不可以对方法的某几行应用事务。】(因为aop拦截的是方法。)
Spring声明式事务管理器类:
Jdbc技术:DataSourceTransactionManager
Hibernate技术:HibernateTransactionManager
# 三、手写Spring事务框架
## 1、编程事务实现
概述
所谓编程式事务指的是通过编码方式实现事务,即类似于JDBC编程实现事务管理。管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理,spring推荐使用TransactionTemplate。
## 2、案例
使用编程事务实现手动事务
// 编程事务(需要手动begin 手动回滚 手动提交)
@Component
public class TransactionUtils {
// 获取事务源
@Autowired
private DataSourceTransactionManager dataSourceTransactionManager;
// 开启事务
public TransactionStatus begin(){
// 默认的传输级别
TransactionStatus transaction = dataSourceTransactionManager.getTransaction(new DefaultTransactionAttribute());
return transaction;
}
// 提交事务
public void commit(TransactionStatus transaction){
dataSourceTransactionManager.commit(transaction);
}
// 回滚事务
public void rollback(TransactionStatus transaction){
dataSourceTransactionManager.rollback(transaction);
}
}
@Service
public class UserServicesImpl implements UserServices {
@Autowired
private UserDao userDao;
@Autowired
private TransactionUtils transactionUtils;
@Override
public void add() {
TransactionStatus transactionStatus = null;
try {
// 开启事务
transactionStatus = transactionUtils.begin();
userDao.add("test001", 20);
System.out.println("#####");
userDao.add("test002", 21);
// 提交事务
if(transactionUtils != null){
transactionUtils.commit(transactionStatus);
}
} catch (Exception e) {
e.printStackTrace();
// 回滚事务
if(transactionUtils != null){
transactionUtils.rollback(transactionStatus);
}
}
}
}
// 切面类 基于手动事务
@Component
@Aspect
public class AopTransaction {
@Autowired
private TransactionUtils transactionUtils;
// TransactionUtils 不要实现为单例: 如果为单例的话,可能会发生线程安全问题
@AfterThrowing("execution(* com.codeobj.service.UserServices.add(..))")
public void afterThrowing(){
System.out.println("回滚事务");
// 获取当前事务 直接进行回滚
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
// 环绕通知在方法之前和之后处理事务
@Around("execution(* com.codeobj.service.UserServices.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
// 调用方法之前执行
System.out.println("开启事务");
TransactionStatus transactionStatus = transactionUtils.begin();
proceedingJoinPoint.proceed(); //代理调用方法 注意点:如果调用方法抛出异常,不会执行后面的代码
System.out.println("提交事务");
// 调用方法之后执行
transactionUtils.commit(transactionStatus);
}
}
@Service
public class UserServicesImpl implements UserServices {
@Autowired
private UserDao userDao;
@Autowired
private TransactionUtils transactionUtils;
@Override
public void add() {
// 注意事项: 在使用spring事务的时候, service 不要try
// 将事务异常抛出给外层aop 进行异常通知后回滚
userDao.add("test001", 20);
System.out.println("#####");
userDao.add("test002", 21);
}
}
事务是程序运行如果没有错误,会自动提交事物,如果程序运行发生异常,则会自动回滚。如果使用了try捕获异常时.一定要在catch里面手动回滚。事务手动回滚代码TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
个人博客 蜗牛