2.Spring常用注解,以及aop原理

2019年3月19日 361次阅读 来源: AOP

​@Component:组件.(作用在类上)

《2.Spring常用注解,以及aop原理》

属性注入的注解:(使用注解注入的方式,可以不用提供 set 方法.)

《2.Spring常用注解,以及aop原理》

Bean 的作用范围的注解:

《2.Spring常用注解,以及aop原理》

Bean 的Th命周期的配置:

《2.Spring常用注解,以及aop原理》

Spring 的 Bean 管理的方式的比较:

《2.Spring常用注解,以及aop原理》

XML 和注解:

  • XML :结构清晰.
  • 注解 :开发方便.(属性注入.)

 

实际开发中还有一种 XML 和注解整合开发:

* Bean 有 XML 配置.但是使用的属性使用注解注入.

​​​​​​​AOP 的概述

《2.Spring常用注解,以及aop原理》

​​​​​​​为什么学习 AOP

对程序进行增强:不修改源码的情况下.

* AOP 可以进行权限校验,日志记录,性能监控,事务控制.

​​​​​​​底层实现:

 

代理机制:

  • Spring 的 AOP 的底层用到两种代理机制：
    • JDK 的动态代理 :针对实现了接口的类产生代理.
    • Cglib 的动态代理 :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术 生成当前类的子类对象.

Spring 底层 AOP 的实现原理:

​​​​​​​JDK 动态代理增强一个类中方法:

public class MyJDKProxy implements InvocationHandler {

  private UserDao userDao;
    
  public MyJDKProxy(UserDao userDao) {
        this.userDao = userDao;
    }

 // 编写工具方法：生成代理：
public UserDao createProxy(){
    UserDao	userDaoProxy = (UserDao)Proxy.newProxyInstance(userDao.getClass().getClassLoader(),
    userDao.getClass().getInterfaces(), this);
    return userDaoProxy;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
if("save".equals(method.getName())){
System.out.println("权限校验================");
}
return method.invoke(userDao, args);
}
}

​​​​​​​Cglib 动态代理增强一个类中的方法:

public class MyCglibProxy implements MethodInterceptor{


private CustomerDao customerDao;


public MyCglibProxy(CustomerDao customerDao){
this.customerDao = customerDao;
}

// 生成代理的方法:
public CustomerDao createProxy(){
// 创建 Cglib 的核心类:
Enhancer enhancer = new Enhancer();
// 设 置 父 类 : enhancer.setSuperclass(CustomerDao.class);
// 设 置 回 调 : enhancer.setCallback(this);
// 生成代理：
CustomerDao customerDaoProxy = (CustomerDao) enhancer.create();
return customerDaoProxy;
}


@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
if("delete".equals(method.getName())){
Object obj = methodProxy.invokeSuper(proxy, args);
System.out.println("日志记录================");
return obj;
}


return methodProxy.invokeSuper(proxy, args);
}
}

​​​​​​​AOP 的开发中的相关术语:

 

Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点.

Pointcut(切入点):所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义.

Advice(通知/增强):所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)

Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field.

Target(目标对象):代理的目标对象

Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.

spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装在期织入

Proxy（代理）:一个类被 AOP 织入增强后，就产生一个结果代理类

Aspect(切面): 是切入点和通知（引介）的结合

Spring 使用 AspectJ 进行 AOP 的开发：XML 的方式

​​​​​​​引入相应的 jar 包

 

* spring 的传统 AOP 的开发的包

spring-aop-4.2.4.RELEASE.jar

com.springsource.org.aopalliance-1.0.0.jar

* aspectJ 的 开 发 包 : com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

spring-aspects-4.2.4.RELEASE.jar

《2.Spring常用注解,以及aop原理》

​​​​​​​引入 Spring 的配置文件

引入 AOP 约束:

<beans xmlns=”http://www.springframework.org/schema/beans” xmlns:xsi=“http://www.w3.org/2001/XMLSchema–instance” 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/aop http://www.springframework.org/schema/aop/spring-aop.xsd”>

</beans>

创建接口和类:
public interface OrderDao { public void save(); public void update(); public void delete(); public void find();
}

public class OrderDaoImpl implements OrderDao {

@Override
public void save() {
System.out.println("保存订单...");
}
@Override
public void update() {
System.out.println("修改订单...");
}

@Override
public void delete() {
System.out.println("删除订单...");
}

@Override
public void find() {
System.out.println("查询订单...");
}

}

 

​​​​​目标类的配置

《2.Spring常用注解,以及aop原理》

​​​​​​​整合 Junit 单元测试

引入 spring-test.jar

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo3 {
@Resource(name="orderDao")
private OrderDao orderDao;

@Test
public void demo1(){ orderDao.save(); orderDao.update(); orderDao.delete(); orderDao.find();
}

​​​​​​​通知类型

前置通知 ：在目标方法执行之前执行. 后置通知 ：在目标方法执行之后执行
环绕通知 ：在目标方法执行前和执行后执行
异常抛出通知：在目标方法执行出现 异常的时候 执行
最终通知 ：无论目标方法是否出现异常 最终通知都会 执行.

​​​​​​​切入点表达式

execution(表达式)

表达式:

[方法访问修饰符] 方法返回值 包名.类名.方法名(方法的参数) public * cn.itcast.spring.dao.*.*(..)

  • cn.itcast.spring.dao.*.*(..)
  • cn.itcast.spring.dao.UserDao+.*(..)
  • cn.itcast.spring.dao..*.*(..)

​​​​​​​编写一个切面类

public class MyAspectXml {
// 前置增强
public void before(){
System.out.println("前置增强===========");
}
}

​​​​​​​配置完成增强

<!-- 配置切面类 -->
<bean id="myAspectXml" class="cn.itcast.spring.demo3.MyAspectXml"></bean>

<!-- 进行 aop 的配置 -->
<aop:config>
<!-- 配置切入点表达式:哪些类的哪些方法需要进行增强 -->
<aop:pointcut	expression="execution(*
cn.itcast.spring.demo3.OrderDao.save(..))" id="pointcut1"/>
<!-- 配置切面 -->
<aop:aspect ref="myAspectXml">
<aop:before method="before" pointcut-ref="pointcut1"/>
</aop:aspect>
</aop:config>

​​​​​​​其他的增强的配置：

<!-- 配置切面类 -->
<bean id="myAspectXml" class="cn.itcast.spring.demo3.MyAspectXml"></bean>
<!-- 进行 aop 的配置 -->
<aop:config>
<!-- 配置切入点表达式:哪些类的哪些方法需要进行增强 -->
<aop:pointcut
cn.itcast.spring.demo3.*Dao.save(..))" id="pointcut1"/>
<aop:pointcut
cn.itcast.spring.demo3.*Dao.delete(..))" id="pointcut2"/>
<aop:pointcut
cn.itcast.spring.demo3.*Dao.update(..))" id="pointcut3"/>
<aop:pointcut
cn.itcast.spring.demo3.*Dao.find(..))" id="pointcut4"/>
<!-- 配置切面 -->
<aop:aspect ref="myAspectXml">
<aop:before method="before" pointcut-ref="pointcut1"/>
<aop:after-returning	method="afterReturing" pointcut-ref="pointcut2"/>
<aop:around method="around" pointcut-ref="pointcut3"/>
<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4"/>
<aop:after method="after" pointcut-ref="pointcut4"/>
</aop:aspect>
</aop:config>

 

 

 

    原文作者：AOP
    原文地址: https://blog.csdn.net/bestkilly/article/details/82182752
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞