Spring AOP

最新推荐文章于 2024-10-19 14:41:34 发布
最新推荐文章于 2024-10-19 14:41:34 发布
阅读量233 收藏
点赞数 1
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PNGYUL/article/details/81585643
版权

什么是AOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。面向切面编程这个概念一直被很多人诟病，因为它和IoC一样晦涩，不太容易理解。

AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率

现在我举个例子，以前我们学习Servlet的时候，几乎每个Servlet都要编写解决乱码代码，假如有很多Servlet,那么我们就要重复的写多次，然而这些横切重复代码无法通过抽象父类的方式提取出来。
后来，我们学习了Filter，我们知道在访问Servle之前，会先访问自定义配置的Filter,这样我们就可以把解决乱码的代码都放到Filter里，这样既解决了乱码问题，也避免了重复代码，提高了开发效率。

AOP独辟蹊径通过横向抽取机制为这类无法通过纵向继承的重复性代码提供了解决方案，AOP希望将这些分散在业务逻辑中的相同代码，通过横向切割的方式抽取到一个独立模块中，我们知道将这些重复性的横切代码提取出来是很容易的，但如何将这些独立的模块融合到业务逻辑中完成和以前一样的操作，这才是关键，也是AOP解决的主要问题。

AOP术语

  • 连接点(Joinpoint)：程序执行的某个特定位置：如类初始化前，类初始化后，某个方法调用前，方法调用后，方法抛出异常后。一个类或一段代码拥有一些具有边界性质的特定点，就被称为 “连接点”。Spring仅支持方法的连接点，仅能在方法调用前后、方法抛出异常时这些连接点织入增强。（目标对象中，所有可以增强的方法）
  • 切点(Pointcut)：每个程序都拥有很多连接点，如有一个两个方法的类，这两个方法都是连接点。如何定位到某个连接点上呢？AOP通过“切点”定位特定的连接点。Spring AOP的解析引擎负责解析切点设定的条件，找到对应的连接点。连接点是方法执行前后等具体程序执行点，而切点只定位到某个方法上，所以如果定位到具体的连接点，还需要提供方位信息，即方法执行前还是执行后。 (目标对象中，已经或者需要增强的方法）
  • 增强/通知(Advice)：增强是织入到目标类连接点上的一段程序代码。在Spring中，增强除了描述一段程序代码外，还拥有另一个和连接点相关的信息，就是执行点的方位。结合方位信息和切点信息，就可以找到特定的连接点。Spring提供的增强接口都是带方位名的：BeforeAdvice，AfterRetuningAdvice，ThrowsAdvice等。所以只有结合切点和增强，才能确定特定的连接点并织入增强代码
  • 目标对象(Target)：需要织入增强代码的目标类。
  • 织入(Weaving)：织入是将增强添加到目标类上具体连接点的过程。
  • 代理(Proxy)：一个类被AOP织入增强后，就产生了一个结果类，它是融合了原类和增强逻辑的代理类。
  • 切面(Aspect)：切面由切点和增强组成，既包括了横切逻辑的定义，也包括了连接点的定义，Spring AOP就是负责实施切面，将定义的横切逻辑织入到切面指定的连接点中。

JDK动态代理和CGLib动态代理

AOP的工作重心在于如何将增强应用于目标对象的连接点上，包括两个工作。

  • 第一：如何通过切点和增强定位到连接点

  • 第二，如何在增强中编写切面的代码。

Spring AOP使用动态代理技术在运行期织入增强的代码。Spring AOP使用了两种代理机制，一种是基于JDK的动态代理；另一种是基于CGLib的动态代理，之所以使用两种代理机制，很大程度上是因为JDK本身只提供接口的代理，不支持类的代理

JDK动态代理

演示一个事务操作的例子：

//用户操作接口
public interface UserService {
    public void save();
    public void delete();
}
//UserService的实现类
public class UserServiceImpl implements UserService {
    public void save() {
        System.out.println("用户信息保存！");
    }
    public void delete() {
        System.out.println("删除用户信息！");
    }
}
//现在我们要开这些操作前添加开启事务和关闭事务。这些动作是相同的，所以我们提取出来 
public class MyAspect {
    public void startTransaction(){
        System.out.println("开启事务...");
    }
    public void commitTransaction(){
        System.out.println("事务提交...");
    }
}
//现在我们需要使用动态代理将增强逻辑和方法编织在一起 
public class MyProxyFactory {
    public  static UserService createUserService(){
        final UserService us=new UserServiceImpl();
        final MyAspect aspect=new MyAspect(); 
        //生成代理对象
        UserService usproxy=(UserService)  Proxy.newProxyInstance(MyProxyFactory.class.getClassLoader(),
         us.getClass().getInterfaces(), new InvocationHandler() {

            @Override
            public Object invoke(Object proxy, Method method, Object[] arg2) throws Throwable {
                aspect.startTransaction();
                Object obj=method.invoke(us, arg2); 
                aspect.commitTransaction();
                return obj;
            }
        });
        return usproxy;
    }

}
//测试
public class TestJDKProxy {
    @Test
    public void test(){
        UserService userService=MyProxyFactory.createUserService();
        userService.save();
    }
}

CGLib动态代理

使用JDK动态代理有一个很大的限制，就是只能为接口创建代理实例。 对于没有通过接口定义的类，如何动态创建代理实例呢？CGLib填补了这么空缺。
我们还使用上面的小例子，不过要稍作一些修改。

//我们还实现一个UserServiceImpl类，但是不需要实现任何接口
public class UserServiceImpl {
    public void save() {
        System.out.println("用户信息保存！");
    }
    public void delete() {
        System.out.println("删除用户信息！");
    }
}
//把横切逻辑代码提取出来
public class MyAspect {
    public void startTransaction(){
        System.out.println("开启事务...");
    }
    public void commitTransaction(){
        System.out.println("事务提交...");
    }
}
//我们使用CGLib生成代理对象
public class CglibProxy {

    public static UserServiceImpl createUserServiceImpl(){  
        //CGLib核心类
        Enhancer enhancer=new Enhancer();
        UserServiceImpl us=new UserServiceImpl ();
        MyAspect aspect=new MyAspect();

        //设置父类，因为CGLib底层是生成需要被代理类的子类
        enhancer.setSuperclass(us.getClass()); 
        //设置回调方法，和InvocationHandler起到的效果一样
        enhancer.setCallback(new org.springframework.cglib.proxy.MethodInterceptor() {

            //intercept方法会拦截所有目标类方法的调用
            //proxy表示目标类的实例，method为目标类方法的反射对象，arg2是方法的参数，arg3是代理类实例
            @Override
            public Object intercept(Object proxy, Method method, Object[] arg2, MethodProxy arg3) throws Throwable {
                aspect.startTransaction();
                Object obj=method.invoke(us, arg2);
                aspect.closeTransaction();
                return obj;
            }
        });
        //创建代理对象
        UserServiceImpl usProxy=(UserServiceImpl ) enhancer.create();
        return usProxy;
    }

}
    //进行测试
    public class TestCGLibProxy {
        @Test
        public void test(){
            UserServiceImpl userServiceImpl =CglibProxy.createUserServiceImpl();
            userServiceImpl .run();
        }

    }

Spring的AOP

我们纯手工的编写创建代理的过程，虽然可以横切逻辑的动态织入，但过程繁琐，为不同类创建代理时，需要分别编写不同的代码，无法做到通用，同时也不利于维护。这时我们就要用到Spring的AOP。

Spring AOP的底层就是通过使用JDK动态代理或者CGLib动态代理技术为目标Bean织入横切逻辑。

Spring AOP通过切点指定在哪些类的哪些方法上织入横切逻辑，通过增强描述横切逻辑代码和方法的具体织入点。Spring通过切面将切点和增强组装起来，通过切面的信息，就可以利用JDK或者CGLib的动态代理技术采用统一通用的方式为Bean创建代理对象。

Spring中增强类型

Spring使用增强类定义横切逻辑，同时由于Spring只支持方法连接点，增强还包括了在方法的哪一点织入横切代码的方位信息，所以增强既包括横切逻辑，还包括连接点的部分信息。

  • 前置增强(Before)：表示在目标方法执行前实施增强。

  • 后置增强(AfterReturning)：表示在目标方法执行后实施增强。

  • 环绕增强(Around)：表示在目标方法的执行前后实施增强。

  • 异常抛出增强(AfterThrowing)：表示在目标方法抛出异常后实施增强。

  • 最终增强 (After)：无论目标方法是否出现异常 最终增强都会执行.

Spring 进行 AOP 开发

我们还是用前面我们用的UserService的例子

//用户操作接口
public interface UserService {
    public void save();
    public void delete();
}
//UserService的实现类
public class UserServiceImpl implements UserService {
    public void save() {
        System.out.println("用户信息保存！");
    }
    public void delete() {
        System.out.println("删除用户信息！");
    }
}
// 我们使实现方法前置增强接口，并写入我们的横切逻辑代码
public class MyBeforeAdvice implements MethodBeforeAdvice {

    // method为目标类的方法，args为目标类方法的所需参数，obj为目标类实例
    public void before(Method method, Object[] args, Object obj) throws Throwable {
            System.out.println("开启事务...");
    }
}
// 我们测试一下
@Test
public void test() {
    UserService us = new UserServiceImpl();
    BeforeAdvice advice = new MyBeforeAdvice();
    // Spring提供的代理工厂
    ProxyFactory pf = new ProxyFactory();
    // 设置代理目标
    pf.setTarget(us);
    // 为代理目标添加增强
    pf.addAdvice(advice);
    // 生成代理对象
    UserService proxy = (UserService) pf.getProxy();
    proxy.save();
}

ProxyFactory代理工厂将增强Advice织入到目标类us中，ProxyFactory内部就是使用JDK动态代理或者CGLib动态代理技术。

Spring使用配置文件声明代理实现AOP

虽然通过ProxyFactory已经简化了很多操作，但是Spring给我们提供了通过配置文件来声明一个代理来让免去硬编码

<!--实例化目标对象-->
<bean id="target" class="com.pngyul.UserServiceImpl"></bean>  
<!--实例化增强对象-->
<bean id="advice" class="com.pngyul.MyBeforeAdvice"></bean> 
<!--实例化代理对象-->
<bean id="proxyus" class="org.springframework.aop.framework.ProxyFactoryBean"> 
    <!--指定代理的接口，有多个的话可以使用数组、list等标签-->
    <property name="proxyInterfaces" value="com.pngyul.UserService"></property> 
    <!--指定使用的增强-->
    <property name="interceptorNames" value="advice"></property> 
    <!--指定代理的目标类-->
    <property name="target" ref="target"></property>
</bean>

ProxyFactoryBean是FactoryBean接口的实现类，我们前一节中介绍了FactoryBean的功能，它负责实例化一个Bean。ProxyFactoryBean负责为其他Bean创建代理对象，内部使用ProxyFactory来完成。我们来了解一下可配置的属性

  • target: 指定要代理的目标对象。

  • proxyInterfaces：代理要实现的接口，可以是多个接口，使用数组、list标签来指定。

  • interceptorNames：需要织入的增强类。 是String[]类型，接受增强Bean的id而不是实例。

  • singleton：返回的代理是否是单实例，默认是单实例。

  • optimize：当设置为true时，强制使用CGLib代理。

  • proxyTargetClass：是否对类进行代理，设置为true，使用CGLib代理。

//我们测试一下
public class Test {
    @Test
    public void test(){
          ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml"); 
          UserService usproxy = (UserService ) ac.getBean("proxyus");
          proxyus.delete();
     }
}

Spring 使用 AspectJ 进行 AOP 开发

AspectJ切点表达式

  • *匹配任意字符，只匹配一个元素

  • .. 匹配任意字符，可以匹配多个元素 ，在表示类时，必须和*联合使用

  • +表示按照类型匹配指定类的所有类，必须跟在类名后面，如com.cad.Car+,表示继承该类的所有子类包括本身

execution(表达式)
表达式 : [方法访问修饰符] 方法返回值 包名.类名.方法名(方法的参数）
public void com.pngyul.spring.service.UserServiceImpl.save()
void com.pngyul.spring.service.UserServiceImpl.save()
* com.pngyul.spring.service.UserServiceImpl.save()
* com.pngyul.spring.service.UserServiceImpl.*()
* com.pngyul.spring.service.*ServiceImpl.*(..)
* com.pngyul.spring.service..* ServiceImpl.*(..)

AspectJ基于XML配置切面

在前面4+2的基础上，我们还需要使用AspectJ我们需要的jar包有如下，同时在需要导入aop约束
这里写图片描述
我们还是用之前那个例子：

//我们先创建UserServiceImpl类
public class UserServiceImpl {
    public void save() {
        System.out.println("用户信息保存！");
    }
    public void delete() {
        System.out.println("删除用户信息！");
    }
}
    //我们创建一个增强类 
    public class AdviceMethod {
        public void before(){
            System.out.println("开启事务!");
        }
    }
    <!--配置文件-->
    <?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"     //声明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">

    <!-实例UserServiceImpl类和增强类-->
    <bean id="us" class="com.pngyul.service.UserServiceImpl"></bean>
    <bean id="advices" class="com.pngyul.AdviceMethod"></bean>

    <!-配置aop，proxy-target-class属性设定为true时，使用CGLib，为false时，使用JDK动态代理-->
    <aop:config proxy-target-class="true"> 
        <!--使用<aop:aspect>标签定义切面，ref引入增强-->
        <aop:aspect ref="advices">
            <!--通过<aop:before>声明一个前置增强，pointcut属性使用切点表达式，method指定使用增强类中方法-->
            <aop:before pointcut="execution(* com.pngyul.service..* ServiceImpl.*(..))"   method="before" />
        </aop:aspect>

    </aop:config>

    <!--我们可以外面配置一个切点，使用时直接引用即可-->
    <!--
    <aop:config proxy-target-class="true">
        <aop:aspect ref="advices"> 
            //定义一个切点
            <aop:pointcut expression="execution(* com.pngyul.service..* ServiceImpl.*(..))" id="mypointcut"/>
            //直接通过id引用即可
           <aop:before pointcut-ref="mypointcut"   method="before" />
        </aop:aspect>
    </aop:config> 
    -->

    </beans>  
 //我们测试一下
 public class TestDemo {
     @Test
     public void test(){
     ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
     UserServiceImpl us=(UserServiceImpl )ac.getBean("us");
     us.save();
     us.delete();
     }
}

再用这个例子展示一下环绕增强：

 //定义环绕增强方法，参数为ProceedingJoinPoint，返回值为Object，这是连接点信息
 public class AdviceMethod {
      public Object around(ProceedingJoinPoint pjp) throws Throwable{
           System.out.println("环绕增强前");
           Object obj=pjp.proceed();
           System.out.println("环绕增强后");
           return obj;
       }
}
<!--配置环绕增强-->
<aop:config proxy-target-class="true">
    <aop:aspect ref="advices">
        <aop:pointcut expression="execution(* com.pngyul.service..* ServiceImpl.*(..))" id="mypointcut"/>
        <aop:around method="around" pointcut-ref="mypointcut"/>
    </aop:aspect>
</aop:config>
 //测试
 public class TestDemo {
     @Test
     public void test(){
     ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
     UserServiceImpl us=(UserServiceImpl )ac.getBean("us");
     us.save();
     us.delete();
     }
}

其他三个配置起来都大同小异，这里就不再一一演示。

AspectJ基于注解配置切面

使用注解配置切面，也需要导入上面的所说的jar包，除此之外，还需要引入aop和context约束

//先使用注解来实例我们的Bean
@Component("us")
public class UserServiceImpl {
    public void save() {
        System.out.println("用户信息保存！");
    }
    public void delete() {
        System.out.println("删除用户信息！");
    }
}
//实例增强类
@Component("advices") 
//使用Aspect
@Aspect
public class AdviceMethod {
      //使用环绕增强，里面参数是切点表达式
      @Around("execution(* com.pngyul.service..* ServiceImpl.*(..))")
      public Object around(ProceedingJoinPoint pjp) throws Throwable{
          System.out.println("环绕增强前");
          Object obj=pjp.proceed();
          System.out.println("环绕增强后");
         return obj;
      }
}
<?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.pngyul.*"></context:component-scan> 
//使用aspectj自动代理，自动为匹配@AspectJ切面的Bean创建代理
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

PS:可能有些例子不太符合某些知识的应用，这里只是单纯的演示一下，没必要较真！！！

PS : 文章自行总结于<春水上行>，了解更多，please click here，

pngyul
关注
专栏目录
SpringAOP(图文详解)
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring AOP全面详解(超级详细)
Cr1556648487的博客
09-09 8万+
AOP （Aspect Orient Programming）,直译过来就是 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术，如下图所示：AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
Spring AOP 详解
最新发布
2301_80035594的博客
10-19 2683
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
SpringAOP学习--SpringAOP简介及原理
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
Spring AOP详解
这河里吗l的博客
06-17 1421
AOP(Aspect-Oriented Programming)面向切面编程，作为面向对象的一种补充，将公共逻辑（事务管理、日志、缓存等）封装成切面，跟业务代码进行分离，可以减少系统的重复代码和降低模块之间的耦合度，并有利于未来的可拓展性和可维护性。
spring aop详解
hanbin1998的博客
04-13 6299
1.前言 spring aop是一个面向切面的编程，在自己第一遍学习的时候，感觉aop没有什么作用，但是真实接触下来，感觉spring aop还是很有用途的，感觉自己之前的想法太年轻了。 2.概念 Spring 提供了两种AOP 的实现：基于注解式配置和基于XML配置，我这里主要就是介绍一下，基于注解式配置。 2.1 AOP 即 Aspect Oriented Program 面向切面编程 首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。 所谓的核心业务，工作中做的最多的
SpringAOP 常见应用场景
Zyw907155124的博客
06-08 2938
常见应用场景:日志记录、权限检查、事务管理、异常处理、性能监控、缓存、参数校验和转换、API调用统计、SLF4J、Logback、Log4j等日志框架集成、自定义注解的处理。 1、AOP实现 性能监控；2、AOP实现 API调用统计；3、AOP实现 缓存；4、AOP实现自定义滑动窗口限流
Spring AOP底层原理、注解和代码样例
热门推荐
用文字记录下每一个瞬间的感动和每一次思考的火花
03-11 11万+
Spring AOP是面向切面编程的一种实现，它允许开发者将横切关注点（如日志、事务管理等）与业务逻辑分离，从而提高代码的模块化和可维护性。在底层，Spring AOP主要通过Java的动态代理机制实现，对于实现了接口的类，它使用JDK动态代理；对于没有实现接口的类，则使用CGLIB代理。连接点（Join Point）表示“在哪里干”；只支持方法执行作为连接点；所有类的所有方法均可以作为连接点。切点（Pointcut）“在哪里干”的集合；
spring aop参数传递
weixin_43931625的博客
04-23 2756
spring aop参数传递
spring aop 注解
面朝大海，春暖花开
02-27 3429
spring Aop 注解 Aop 术语 AOP 的特性术语，不同的翻译还会不一样，得在过程中理解 横切关注点：跨越程序多个模块的方法或功能。即与业务逻辑无关，但我们也要关注的部分，就是横切关注点。如日志、安全、缓存等。 切面（ Aspect ）：横切关注点被模块化的特殊对象；即切面应是一个类。 通知（ Advice）：切面要完成的增强处理，通知描述了切面何时执行以及如何执行增强处理；即通知应是切面中的方法。 目标（ Target ）：被通知对象。 代理（ Proxy ）：向目标对象应用通知之后创建的对象
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
Spring源码最难问题：当Spring AOP遇上循环依赖.docx
06-15
Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
Spring基于注解方式装配Bean
pngyul的博客
08-14 6819
开启使用注解代理配置文件 Spring提供了组件扫描，来进行对指定包进行扫描，对拥有注解的类进行实例化等操作。 &amp;amp;amp;lt;!--组件扫描：Spring容器会扫描这个包里所有类，从类的注解信息中获取Bean的信息--&amp;amp;amp;gt; &amp;amp;amp;lt;context:component-scan base-package=&amp;amp;quot;com.pngyul.domain&amp;amp;q
Spring IOC的配置与注入
pngyul的博客
08-11 648
Spring的体系结构 整个Spring框架按其所属功能可以划分为五个主要模块，这五个模块几乎为企业应用提供了所需的一切，从持久层、业务层到表现层都拥有相应的支持，这就是Spring为什么是一站式框架。IoC和AOP是Spring的核心。 -核心模块(Core Container) pring的核心模块实现了IoC的功能，它将类和类之间的依赖从代码中脱离出来，用配置的方式进行依赖关系描...
Spring整合JDBC与AOP事务
pngyul的博客
08-16 511
Spring JDBC Spring模板和回调机制 在直接使用JDBC时。我们需要处理获取连接，处理异常、释放资源等整个流程。Spring为支持的持久化技术提供了模板访问的方式，我们只需要提供具体的操作数据代码即可，可以大幅度提高开发效率。 Spring将相同的数据访问流程固定到模板类中，例如，获取连接、释放资源等等。将数据库操作中固定和变化的部分分开，同时保证模板类线程安全，以便多个线程共...
再扯 Spring 源码_白话文
pngyul的博客
03-10 387
在2021年之前，我在网上看过很多beam的 生命周期或者Aop相关源码的文章，并且自己简单实现了一个玩具级的Ioc 容器。所以如果说在面试过程中，面试官跟我扯beam的 生命周期或者Aop相关实现的话，我是非常的自信自己可以扯一大堆东西出来。但是如果再深入的话，我就很难说出来了。比如 @Bean 是在哪里实现的？@AutoWired 是如何实现的，核心是实现类是什么，Spring　的事件原理等等。 我真的很好奇，以至于今年年初，带着这些问题大致又刷了一篇。对ｂｅａｎＦａｃｔｏｒｙ甚至对Spring的核心思
spring aop
09-11
Spring AOP（Aspect-Oriented Programming）是Spring框架中的一个重要特性，它提供了一种在应用程序中实现横切关注点（cross-cutting concerns）的方法。所谓横切关注点，指的是那些在应用程序中散布于各个模块之中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值