【简记】Java Web 内幕——Spring中AOP的实现

最新推荐文章于 2023-09-29 17:07:14 发布
最新推荐文章于 2023-09-29 17:07:14 发布
阅读量276 收藏 1
点赞数
分类专栏： java web spring（使用+源码）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqqqq1993qqqqq/article/details/74906532
版权

本章内容：
https://www.cnblogs.com/linzhong/p/7234051.html

  • 代理模式
  • 静态代理实现
  • 动态代理实现（JDK，Cglib），也是Spring底层的实现
  • Spring中的代理实现（利用注解或xml）
  • 切入点表达式

####AOP的实现——代理模式
代理（Proxy）是一种设计模式， 提供了对目标对象另外的访问方式，即通过代理访问目标对象。
好处： 可以在目标对象实现的基础上，增强额外的功能操作。（扩展目标对象的功能）。

代理模式的关键点： 代理对象与目标对象。

####静态代理

  • 可以做到在不修改目标对象的前提下，对目标对象功能扩展
  • 静态代理在使用时，需要定义接口或是父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类。
  • 静态代理存在两个缺点
    1）代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
    2）如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
/**
 * 代理对象(静态代理)
 * 	   代理对象，要实现与目标对象一样的接口
 * @author Jie.Yuan
 *
 */
public class UserDaoProxy implements IUserDao{

	// 接收保存目标对象
	private IUserDao target;
	public UserDaoProxy(IUserDao target) {
		this.target = target;
	}
	
	@Override
	public void save() { // 方法名相同，这样才能保证代理过程对外是透明的
		System.out.println("开始事务...");
		
		target.save(); 			// 执行目标对象的方法
		
		System.out.println("提交事务...");
	}

}

解决：
代理工厂？ 可以使用动态代理。

####动态代理

动态代理，
1）代理对象，不需要实现接口；
2）代理对象的生成，是利用JDK API， 动态的在内存中构建代理对象（需要我们指定创建 代理对象/目标对象 实现的接口的类型）;
3) 动态代理， JDK代理， 接口代理；

package java.lang.reflect; // 反射的包中
public static Object newProxyInstance(ClassLoader loader,  // 指定当前目标对象使用类加载器
Class<?>[] interfaces, // 目标对象实现的接口的类型
InvocationHandler h // 事件处理器
)

接口类IUserDao

IUserDao target = new UserDao();

目标对象UserDao

/**
 * 接口实现
 * 目标对象
 */
public class UserDao implements IUserDao {

    public void save() {

        System.out.println("----保存数据成功!----");
    }

}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 *
 * 代理工厂，给所有的dao创建代理对象【动态代理】
 *
 * 代理对象，不需要实现接口
 *
 */
public class ProxyFactory {

	// 维护一个目标对象
	private Object target;
	public ProxyFactory(Object target){
		this.target = target;
	}

	// 给目标对象生成代理对象
	public Object getProxyInstance() {
		return Proxy.newProxyInstance(
				target.getClass().getClassLoader(),
				target.getClass().getInterfaces(),
				new InvocationHandler() {
					@Override
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						System.out.println("开启事务");

						// 执行目标对象方法
						Object returnValue = method.invoke(target, args);

						System.out.println("提交事务");
						return returnValue;
					}
				});
	}
}

public class App {
	public static void main(String[] args) {
		// 目标对象
		IUserDao target = new UserDao();
		// 【原始的类型 class b.dynamic.UserDao】
		System.out.println(target.getClass());

		// 给目标对象，创建代理对象
		IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
		// class com.sun.proxy.$Proxy0   内存中动态生成的代理对象
		System.out.println(proxy.getClass());

		// 执行方法   【代理对象】
		proxy.save();
	}
}

动态代理总结：
代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！

####Cglib子类代理

如果想代理没有实现接口的类，就可以使用CGLIB实现。

Cglib代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。（子类继承了父类，也就是被代理对象的所有方法）

  • CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring
    AOP和dynaop，为他们提供方法的interception（拦截）。
  • CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

在调用目标方法时，CGLib会回调MethodInterceptor接口方法拦截，来实现你自己的代理逻辑，类似于JDK中的InvocationHandler接口。

public class ProxyFactory implements MethodInterceptor {

    // 维护目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    // 给目标对象创建代理对象
    public Object getProxyInstance() {
        //1. 工具类
        Enhancer en = new Enhancer();
        //2. 设置父类
        en.setSuperclass(target.getClass());
        //3. 设置回调函数
        en.setCallback(this);
        //4. 创建子类(代理对象)
        return en.create(); 
    }


    @Override
    public Object intercept(Object obj, Method method, Object[] args,
                            MethodProxy proxy) throws Throwable {
        System.out.println("开始事务.....");
        // 执行目标对象的方法
        Object returnValue = method.invoke(target, args);
        System.out.println("提交事务.....");
        return returnValue;
    }
}

	public class App {

		public static void main(String[] args) {
			// 目标对象
			UserDao target = new UserDao();
			// class class c.cglib.UserDao
			System.out.println(target.getClass());
			// 代理对象
			UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance();
			// UserDao子类：class c.cglib.UserDao$$EnhancerByCGLIB$$e3ae3440
			System.out.println(proxy.getClass());
			// 执行代理对象的方法
			proxy.save();
		}
	}

总结：
1）代理的类不能为final， 否则报错（因为无法生成子类）。
2） 目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法。

在Spring的AOP编程中，
如果加入容器的目标对象有实现接口，用JDK代理；
如果目标对象没有实现接口，用Cglib代理；

####手动实现AOP编程

AOP可以实现“业务代码”与“关注点代码”分离。

try { 
	session = HibernateSessionFactoryUtils.getSession();   // 【关注点代码】
	trans = session.beginTransaction();    // 【关注点代码】
			 
	session.save(user);     // 核心业务代码
			 
	trans.commit();     //…【关注点代码】

		}

分析总结：关注点代码，就是指重复执行的代码。
业务代码与关注点代码分离，好处？

  • 关注点代码写一次即可；
  • 开发者只需要关注核心业务；
  • 运行时期，执行核心业务代码时候动态织入关注点代码； 【代理】
public class ProxyFactory {

	// 目标对象
	private static Object target;
	private static Aop aop;

	// 生成代理对象的方法
	public static Object getProxyInstance(Object target_,Aop aop_){

		target = target_;
		aop = aop_;

		return Proxy.newProxyInstance(
				target.getClass().getClassLoader(),
				target.getClass().getInterfaces(),
				new InvocationHandler() {

					@Override
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						aop.begin();// 执行重复代码

						// 执行目标对象的方法
						Object returnValue = method.invoke(target, args);

						aop.commite(); // 执行重复代码
						return returnValue;
					}
				});
	}
}

<!-- 调用工厂方法，返回UserDao代理后的对象 -->
    <bean id="userDao_proxy" class="d.myaop.ProxyFactory" factory-method="getProxyInstance">
        <constructor-arg index="0" ref="userDao"></constructor-arg>
        <constructor-arg index="1" ref="aop"></constructor-arg>
    </bean>

####注解方式实现AOP编程
切面：
关注点形成的类，就叫切面(类)！
面向切面编程，就是指 对很多功能都有的重复的代码抽取，再在运行的时候往业务方法上动态植入“切面类代码”。

切入点：
执行目标对象方法，动态植入切面代码。
可以通过切入点表达式，指定拦截哪些类的哪些方法； 给指定的类在运行的时候植入切面类代码。

@Component
@Aspect  // 指定当前类为切面类
public class Aop {

	// 指定切入点表单式： 拦截哪些方法； 即为哪些类生成代理对象

	@Pointcut("execution(* e.aop.*.*(..))") // *:通配符, （..)代表任意参数
	public void pointCut_(){
	}

	// 前置通知 : 在执行目标方法之前执行
	@Before("pointCut_()")
	public void begin(){
		System.out.println("开始事务/异常");
	}

	// 后置/最终通知：在执行目标方法之后执行  【无论是否出现异常最终都会执行】
	@After("pointCut_()")
	public void after(){
		System.out.println("提交事务/关闭");
	}

	// 返回后通知： 在调用目标方法结束后执行 【出现异常不执行】
	@AfterReturning("pointCut_()")
	public void afterReturning() {
		System.out.println("afterReturning()");
	}

	// 异常通知： 当目标方法执行异常时候执行此关注点代码
	@AfterThrowing("pointCut_()")
	public void afterThrowing(){
		System.out.println("afterThrowing()");
	}

	// 环绕通知：环绕目标方式执行
	@Around("pointCut_()")
	public void around(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("环绕前....");
		pjp.proceed();  // 执行目标方法
		System.out.println("环绕后....");
	}

}

public class App {

	ApplicationContext ac =
			new FileSystemXmlApplicationContext("E:/mavenspring/src/main/java/e/aop/bean.xml");

	// 目标对象有实现接口，spring会自动选择“JDK代理”
	@Test
	public void testApp() {
		IUserDao userDao = (IUserDao) ac.getBean("userDao");
		System.out.println(userDao.getClass());//$Proxy001
		userDao.save();
	}

	// 目标对象没有实现接口， spring会用“cglib代理”
	@Test
	public void testCglib() {
		OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
		System.out.println(orderDao.getClass());
		orderDao.save();
	}

	@Deprecated
	// 共性问题：如果目标对象有实现接口，在从容器中获取目标对象的时候，只能通过接口接收对象。
	public void testApp2() {
		// 错误代码： 只能用接口接收
		UserDao userDao = (UserDao) ac.getBean("userDao");
		System.out.println(userDao.getClass());//$Proxy001
		userDao.save();
	}


	@Test
	public void testGetObj() throws Exception {
		OrderDao orderDao1 = (OrderDao) ac.getBean("orderDao");
		OrderDao orderDao2 = (OrderDao) ac.getBean("orderDao");

		System.out.println(orderDao1);
		System.out.println(orderDao2);

	}
}

@Aspect 指定一个类为切面类
@Pointcut(“execution(* cn.itcast.e_aop_anno..(…))”) 指定切入点表达式

@Before(“pointCut_()”) 前置通知: 目标方法之前执行
@After(“pointCut_()”) 后置通知：目标方法之后执行（始终执行）
@AfterReturning(“pointCut_()”) 返回后通知： 执行方法结束前执行(异常不执行)
@AfterThrowing(“pointCut_()”) 异常通知: 出现异常时候执行
@Around(“pointCut_()”) 环绕通知： 环绕目标方法执行

####XML方式实现AOP编程
1） 引入aop名称空间
2）aop 配置
* 配置切面类 （重复执行代码形成的类）
* aop配置
拦截哪些方法 / 拦截到方法后应用通知代码

--------------------------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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    ---------------声明aop命名空间-------------------
    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">

    <!-- dao 实例 -->
    <bean id="userDao" class="cn.itcast.f_aop_xml.UserDao"></bean>
    <bean id="orderDao" class="cn.itcast.f_aop_xml.OrderDao"></bean>

    <!-- 切面类 -->
    <bean id="aop" class="cn.itcast.f_aop_xml.Aop"></bean>

    <!-- Aop配置 -->
    <aop:config>
        <!-- 定义一个切入点表达式： 拦截哪些方法 -->
        <aop:pointcut expression="execution(* cn.itcast.f_aop_xml.*.*(..))" id="pt"/>
        <!-- 切面 -->
        <aop:aspect ref="aop">
            <!-- 环绕通知 -->
            <aop:around method="around" pointcut-ref="pt"/>
            <!-- 前置通知： 在目标方法调用前执行 -->
            <aop:before method="begin" pointcut-ref="pt"/>
            <!-- 后置通知： -->
            <aop:after method="after" pointcut-ref="pt"/>
            <!-- 返回后通知 -->
            <aop:after-returning method="afterReturning" pointcut-ref="pt"/>
            <!-- 异常通知 -->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>

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

####切入点表达式

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern)
throws-pattern?)
修饰符（可选），返回类型，描述类型（可选），方法名，（参数类型），异常类型（可选）

All parts except the returning type pattern (ret-type-pattern in the snippet above), name pattern, and
parameters pattern are optional.


        <!-- 定义一个切入点表达式： 拦截哪些方法 -->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.*.*(..))" id="pt"/>-->

        <!-- 【拦截所有public方法】 -->
        <!--<aop:pointcut expression="execution(public * *(..))" id="pt"/>-->

        <!-- 【拦截所有save开头的方法 】 -->
        <!--<aop:pointcut expression="execution(* save*(..))" id="pt"/>-->

        <!-- 【拦截指定类的指定方法, 拦截时候一定要定位到方法】 -->
        <!--<aop:pointcut expression="execution(public * cn.itcast.g_pointcut.OrderDao.save(..))" id="pt"/>-->

        <!-- 【拦截指定类的所有方法】 -->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.*(..))" id="pt"/>-->

        <!-- 【拦截指定包，以及其自包下所有类的所有方法】 -->
        <!--<aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>-->

        <!-- 【多个表达式】 -->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) || execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) or execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
        <!-- 下面2个且关系的，没有意义 -->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) &amp;&amp; execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) and execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

        <!-- 【取非值】 -->
        <!--<aop:pointcut expression="!execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
        <aop:pointcut expression=" not execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>
qqqqq1993qqqqq
关注
专栏目录
Spring-AOP编程(JavaConfig)
chr1sgong的博客
01-19 1274
本文是Spring AOP官方文档部分内容的简记。 1，Introduction Spring IoC容器不依赖于AOP，但是作为IoC容器的补充，AOP提供了非常强大的中间件解决方案。 AOP在Spring框架中的用途： 提供声明式企业级服务，特别是作为EJB声明式服务的替代品，典型的应用就是Spring声明式事务管理。 允许用户自定义切面 1.1，AOP概念 切面（A
项目简记——关于spring与structs2结合的理解
xiluoduyu
11-30 1073
项目简记——关于spring与structs2结合的理解最近因为接手了一个Java的平台开发（唉，同事离职了扔给我的，又是一堆的坑要填…），所以从Django转而学spring和structs2。在此简单记录下学习中的理解，后续完善。因为有C++基础，Java语言本身对我没啥障碍，所以首先从java的web框架入手。本以为将Django框架那一套配置思路迁移过去，应该很容易理解spring的，结果发
【简记】Java Web 内幕——Spring源码（组件分析，BeanFactory源码，Bean创建之前）
qqqqq1993qqqqq的博客
07-10 1768
本章内容： Bean组件、Context组件解析 BeanFactory的创建 初始化Bean实例之前的操作 Bean组件解析Spring Bean 的创建是典型的工厂模式， 它的顶级接口是BeanFactory。Bean工厂的类层次关系图： 4个接口，共同定义了Bean 的集合、Bean 之间的关系和Bean 的行为。Bean定义的类层次关系图： Bean 的定义完整地描述了在Spring
【简记】Java Web 内幕——CDN简介
qqqqq1993qqqqq的博客
07-07 2074
CDN 也就是内容分布网络( Content Delivery Network ) ，它是构筑在现有Internet 上的一种先进的流量分配网络。其目的是通过在现有的Internet 中增加一层新的网络架构，将网站的内容发布到最接近用户的网络”边缘”，使用户可以就近取得所需的内容，提高用户访问网站的响应速度。有别于镜像， 它比镜像更智能， 可以做这样一个比喻: CDN = 镜像( Mirror )
【简记】Java Web 内幕——Mybatis初始化，数据源与连接池，事务管理
qqqqq1993qqqqq的博客
07-30 1193
本文是对教程精华的部分摘录和感想 Mybatis初始化机制详解http://blog.csdn.net/luanlouis/article/details/37744073MyBatis初始化的过程，就是创建 Configuration对象的过程。简单介绍基于XML文件的初始化过程：String resource = "mybatis-config.xml"; InputStream input
Spring结合自定义注解实现 AOP 切面功能【详解】
最新发布
qq_27480007的博客
09-29 1331
Spring结合自定义注解实现 AOP 切面功能
Spring Boot脚手架创建简记
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
02-19 2142
不同的企业开发新项目时都会用相同的框架，经过长期的迭代和扩展，每个团队可能都会有固定的框架模板，这里笔者就来介绍一下自己常用的一套脚手架的制作过程。
Java后端真实面试题大全(有详细答案)--高频/真题
热门推荐
IT利刃出鞘的博客
11-24 14万+
本文分享Java后端真实高频面试题，有详细答案，保你稳过面试。题目包括：Java基础、多线程、JVM、数据库、Redis、Shiro、Spring、SpringBoot、MyBatis、MQ、ELK、SpringCloud、设计模式等。 本博客包含从简单到困难、从高频到低频的题目，适合所有Java求职者，包括：刚入门的、三年以内经验、三到五年经验、五到十年经验等。
Spring---AOP简介
爱上在路上
08-16 523
1、引言 考虑这样一个问题：需要对系统中的某些业务做日志记录，比如支付系统中的支付业务需要记录支付相关日志，对于支付系统可能相当复杂，比如可能有自己的支付系统，也可能引入第三方支付平台，面对这样的支付系统该如何解决呢？ 1.1 传统解决方案： 1）日志部分提出公共类LogUtils，定义“longPayBegin”方法用于记录支付开始日志，“logPayEnd”用于记录支付结果
NLP学习————实现一个BERT（简记）
qq_51485453的博客
08-22 673
NLP学习————实现一个BERT（简记） 本文主要内容是介绍了BERT的代码结构、具体实现与原理，对BERT的一些简记 内容包括以下几个部分: BERT Tokenization 分词模型（BertTokenizer） BERT Model 本体模型（BertModel） BertEmbeddings BertEncoder BertLayer BertAttention BertIntermediate BertOutput BertPooler 本文内容的结构图如下： 具体的内
【简记】Computer Networking——physical layer
qqqqq1993qqqqq的博客
06-06 450
本章主要任务： （1）物理层的任务 （2）几种常用的信道复用技术 （3）几种常用的宽带接入技术，主要是ADSL和FTTx2.1 物理层的基本概念物理层的任务是传输数据比特流。 物理层的作用是尽可能地屏蔽掉传输媒体和通信手段的差异，使得物理层上面的数据链路层感觉不到这些差异。物理层的主要任务描述为确定与传输媒体的接口的一些特性，即： 机械特性 指明接口所用接线器的形状和尺寸、引线数目和
【简记】Operating System——Atomic Transaction Overview
qqqqq1993qqqqq的博客
07-02 530
This memo is based on the course of Dr.Li with Operating System as the reference book.本章内容： 原子事务 原子事务6.9.1 系统模型执行单个逻辑功能的一组指令或操作称为事务。可以认为事务是访问且可能更新各种驻留在磁盘文件中的数据项的程序单元。从用户观点来看，事务只是一系列read 操作和write 操作， 井以
【简记】Operating System—— file system in Linux
qqqqq1993qqqqq的博客
07-05 528
This memo is based on the course of Dr.Li with Operating System as the reference book.本章内容： Linux文件结构 Linux文件系统概述 一 、Linux文件结构 　　Linux采用的是树型结构。最上层是根目录，其他的所有目录都是从根目录出发而生成的。微软的DOS和windows也是采用树型结构，但是在DOS和
正则表达式简记（一）—— 如何表达整数 & RegExp 的一些方法、string正则相关
catherine_sfy的博客
08-09 1114
一、JS 》有关正则表达式 正则表达式是用于匹配字符串中字符组合的模式。在 JavaScript中，正则表达式也是对象。这些模式被用于 RegExp 的 exec 和 test 方法, 以及 String 的 match、replace、search 和 split 方法。 正则表达式如何表示整数？ /^-?\d+$/　　　　//整数 解读： ^: 匹配输入的开始。如果多行标志被设置为tru...
spring源码走读系列 —— 事务的传播机制
qqqqq1993qqqqq的博客
04-10 1043
本文的源码位于 org.springframework.transaction.TransactionDefinition 该类定义了事务的传播机制 PROPAGATION_REQUIRED spring 的默认传播机制 。支持方法在当前事务中运行，如果当前不存在事务则新建一个事务。所以如果配置为该级别，则一定能保证在事务中运行。 /** * Support a current transaction; create a new one if none exists. * Analogous
Spring技术内幕——AOP的实现
qqqqq1993qqqqq的博客
09-09 418
维基百科对“AOP”相关概念的叙述： Aspect是一种新的模块化机制，用来描述分散在对象、类或函数中的横切关注点（crosscutting concern）。从关注点中分离出横切关注点是面向切面的程序设计的核心概念。分离关注点使解决特定领域问题的代码从业务逻辑中独立出来，业务逻辑的代码中不再含有针对特定领域问题代码的调用，业务逻辑同特定领域问题的关系通过切面来封装、维护，这样原本分散在整个
【简记】Java Web 内幕——Spring中的事务操作和底层源码
qqqqq1993qqqqq的博客
07-10 370
本章内容： Spring中事务使用 事务的底层操作 事务控制环境准备（Struts框架） 用户访问—》Action –》 Service—》Dao一个业务的成功： 调用的service是执行成功的，意味着service中调用的所有的dao是执行成功的。 事务应该在Service层统一控制。编程式事务控制自己手动控制事务，就叫做编程式事务控制。 Jdbc代码： Conn.setAutoC
Spring技术内幕——IOC部分摘录
qqqqq1993qqqqq的博客
09-08 362
哪些方面的控制被反转了？（名词“依赖注入”的由来） Spring IOC的容器设计中，有两种主要的容器系列，一个是实现BeanFactory接口的简单容器系列；另一个是ApplicationContext应用上下文，增加了许多面向框架的特性同时对应用环境做了适配。 （下图中全是接口） 三套接口体系：  1、从接口BeanFactory道Hierarchica
【简记】Java Web 内幕——AOP源码
qqqqq1993qqqqq的博客
07-10 353
本章内容： AOP实现源码 这里最值得注意的一点是最左下角的那个方框，我用几句话总结一下： AspectJAwareAdvisorAutoProxyCreator是BeanPostProcessor接口的实现类 postProcessBeforeInitialization方法与postProcessAfterInitialization方法实现在父类AbstractAutoProxyCreat
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值