Spring注入与AOP详解_spring aop 和注入-CSDN博客

本文链接：https://blog.csdn.net/a707819156/article/details/79814847

Spring_day02总结

今日任务

案例一使用Spring的AOP对客户管理的DAO进行增强

1.1 案例需求

1.1.1 需求描述

对于CRM的系统而言，现在有很多的DAO类，比如客户的DAO，联系人DAO等等。客户提出一个需求要开发人员实现一个功能对所有的DAO的类中以save开头的方法实现权限的校验，需要时管理员的身份才可以进行保存操作。

1.2 相关知识点

1.2.1 Spring的Bean管理:(注解方式)

1.2.1.1 步骤一:下载Spring的开发包:

官网：http://spring.io/

下载地址：http://repo.springsource.org/libs-release-local/org/springframework/spring解压:(Spring目录结构:)

* docs:API和开发规范.

* libs:jar包和源码.

* schema:约束.

1.2.1.2 步骤二:创建web项目,引入Spring的开发包:

在Spring的注解的AOP中需要引入spring-aop的jar包。

1.2.1.3 步骤三:引入相关配置文件:

log4j.properties

applicationContext.xml

引入约束:

spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

* 引入约束:(引入context的约束):

</beans>

1.2.1.4 步骤四:编写相关的类:

public interface UserDao {

public void sayHello();

}

public class UserDaoImpl implements UserDao {

@Override

public void sayHello() {

System.out.println("Hello Spring...");

}

1.2.1.5 步骤五:配置注解扫描

<context:component-scan base-package="com.itheima.spring.demo1"/>

1.2.1.6 在相关的类上添加注解:

@Component(value="userDao")

public class UserDaoImpl implements UserDao {

@Override

public void sayHello() {

System.out.println("Hello Spring Annotation...");

}

1.2.1.7 编写测试类:

@Test

public void demo2() {

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(

"applicationContext.xml");

UserDao userDao = (UserDao) applicationContext.getBean("userDao");

userDao.sayHello();

}

1.2.2 Spring的Bean管理的中常用的注解:

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

Spring中提供@Component的三个衍生注解:(功能目前来讲是一致的)

* @Controller:WEB层

* @Service:业务层

* @Repository:持久层

这三个注解是为了让标注类本身的用途清晰，Spring在后续版本会对其增强

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

@Value:用于注入普通类型.

@Autowired:自动装配:

* 默认按类型进行装配.

* 按名称注入:

* @Qualifier:强制使用名称注入.

@Resource相当于:

* @Autowired和@Qualifier一起使用.

1.2.2.3 Bean的作用范围的注解:

@Scope:

* singleton:单例

* prototype:多例

1.2.2.4 Bean的生命周期的配置:

@PostConstruct:相当于init-method

@PreDestroy:相当于destroy-method

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

XML和注解:

* XML:结构清晰.

* 注解:开发方便.(属性注入.)

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

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

1.2.4 AOP的概述

1.2.4.1 什么是AOP

Spring是解决实际开发中的一些问题:

* AOP解决OOP中遇到的一些问题.是OOP的延续和扩展.

1.2.4.2 为什么学习AOP

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

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

1.2.4.3 Spring的AOP的由来:

AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范.

1.2.4.4 底层实现:

代理机制:

* Spring的AOP的底层用到两种代理机制：

* JDK的动态代理:针对实现了接口的类产生代理.

* Cglib的动态代理:针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术生成当前类的子类对象.

1.2.5 Spring底层AOP的实现原理:（了解）

1.2.5.1 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);

}

1.2.5.2 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);

}

1.2.6 Spring的基于AspectJ的AOP开发

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

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

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

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

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

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

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

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

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

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

1.2.7 Spring使用AspectJ进行AOP的开发：XML的方式（*）

1.2.7.1 引入相应的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

1.2.7.2 引入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>

1.2.7.3 编写目标类

创建接口和类:

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("查询订单...");

}

1.2.7.4 目标类的配置

</bean>

1.2.7.5 整合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();

}

1.2.7.6 通知类型

前置通知：在目标方法执行之前执行.

后置通知：在目标方法执行之后执行

环绕通知：在目标方法执行前和执行后执行

异常抛出通知：在目标方法执行出现异常的时候执行

最终通知：无论目标方法是否出现异常最终通知都会执行.

1.2.7.7 切入点表达式

execution(表达式)

表达式:

[方法访问修饰符] 方法返回值包名.类名.方法名(方法的参数)

public * cn.itcast.spring.dao.*.*(..)

* cn.itcast.spring.dao.*.*(..)

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

* cn.itcast.spring.dao..*.*(..)

1.2.7.8 编写一个切面类

public class MyAspectXml {

// 前置增强

public void before(){

System.out.println("前置增强===========");

}

1.2.7.9 配置完成增强

<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>

1.2.7.10 其他的增强的配置：

<aop:config>

<aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.save(..))" id="pointcut1"/>

<aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.delete(..))" id="pointcut2"/>

<aop:pointcut expression="execution(* cn.itcast.spring.demo3.*Dao.update(..))" id="pointcut3"/>

<aop:pointcut expression="execution(* 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>

Spring注入与AOP详解

1.1 案例需求

1.1.1 需求描述

1.2 相关知识点

1.2.1 Spring的Bean管理:(注解方式)

1.2.1.1 步骤一:下载Spring的开发包:

1.2.1.2 步骤二:创建web项目,引入Spring的开发包:

1.2.1.3 步骤三:引入相关配置文件:

1.2.1.4 步骤四:编写相关的类:

1.2.1.5 步骤五:配置注解扫描

1.2.1.6 在相关的类上添加注解:

1.2.1.7 编写测试类:

1.2.2 Spring的Bean管理的中常用的注解:

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

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

1.2.2.3 Bean的作用范围的注解:

1.2.2.4 Bean的生命周期的配置:

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

1.2.4 AOP的概述

1.2.4.1 什么是AOP

1.2.4.2 为什么学习AOP

1.2.4.3 Spring的AOP的由来:

1.2.4.4 底层实现:

1.2.5 Spring底层AOP的实现原理:（了解）

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

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

1.2.6 Spring的基于AspectJ的AOP开发

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

1.2.7 Spring使用AspectJ进行AOP的开发：XML的方式（*****）

1.2.7.1 引入相应的jar包

1.2.7.2 引入Spring的配置文件

1.2.7.3 编写目标类

1.2.7.4 目标类的配置

1.2.7.5 整合Junit单元测试

1.2.7.6 通知类型

1.2.7.7 切入点表达式

1.2.7.8 编写一个切面类

1.2.7.9 配置完成增强

1.2.7.10 其他的增强的配置：

1.2.7 Spring使用AspectJ进行AOP的开发：XML的方式（*）