Spring(三)AOP面向切面编程

原文链接:http://www.orlion.ga/205/

一、AOP简介

1、AOP概念

参考文章:http://www.orlion.ml/57

2、AOP的产生

对于如下方法:

    public class UserDAOImpl implements UserDAO{
    
    	public void saveUser(User user){
    		doSaveUser();
    	}
    }

想在saveUser方法中执行保存用户之前和之后记录当前时间以求出saveUser花费了多少时间,方法有很多种,最直观的写法就是在doSaveUser()前后加代码取出当前时间:

    public class UserDAOImpl implements UserDAO{
    
    	public void saveUser(User user){
    		int beginTime = getCurrentTime();
    
    		doSaveUser();
    
    		int endTime = getCurrentTime();
    	}
    }

还有一种方法就是重新写一个类继承自UserDAOImpl然后重写saveUser方法,如下:

    public class UserDAOImpl2 extends UserDAOImpl{
        @Override
	public void saveUser(User user){
		int beginTime = getCurrentTime();

		super.saveUser();

		int endTime = getCurrentTime();
	}
    }

这种方法耦合性太强,一旦父类改变了子类也会改变,慎用继承

再有一种方法就是在调用saveUser()方法时加代码:

    public class UserService{
        
	public void saveUser(User user){
	        UserDAOImpl userDao = new UserDAOImpl();
		int beginTime = getCurrentTime();

		userDao.saveUser();

		int endTime = getCurrentTime();
	}
    }

现在如果让我们将项目中所有的对数据库进行CRUD操作的方法都加上获取时间的代码,显然工作量太大,这时候就用动态代理: (可参考http://www.orlion.ml/207/)

UserDAOImpl.java

    package ml.orlion.dao.impl;
    
    import ml.orlion.dao.UserDAO;
    import ml.orlion.model.User;
    
    public class UserDAOImpl implements UserDAO{
    
    	public void saveUser(User user){
    		System.out.println("save usering");
    	}
    }

TimeInterceptor.java

    package ml.orlion.aop;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    public class TimeInterceptor implements InvocationHandler{
    
    	private Object target;// 被代理的对象
    
    	public Object getTarget() {
    		return target;
    	}
    	public void setTarget(Object target) {
    		this.target = target;
    	}
    	public void beforeMethod(Method m){
    		System.out.println(m.getName() + "begin start");
    	}
    	@Override
    	public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
    
    		this.beforeMethod(m);// 插入方法
    		m.invoke(target, args);
    		return null;
    	}
    }

测试

    public static void testProxy(){
	// 首先产生一个被代理对象
	UserDAO userDao = new UserDAOImpl();
	// 下一步将被代理对象交给InvocationHandler即TimeInterceptor
	TimeInterceptor ti = new TimeInterceptor();
	// 设置被代理对象
	ti.setTarget(userDao);
	// 根据被代理对象产生一个代理
	UserDAO userProxy = (UserDAO)Proxy.newProxyInstance(UserDAO.class.getClassLoader(), new Class[]{UserDAO.class}, ti);
	userProxy.saveUser(new User());
    }

运行可以看到控制台打印:saveUserbegin start      save usering

二、使用Spring AOP

UserDAO.java:

package ml.orlion.dao;

import ml.orlion.model.User;

public interface UserDAO {
	public void saveUser(User user);
}

UserDAOImpl.java:

package ml.orlion.dao.impl;

import ml.orlion.dao.UserDAO;
import ml.orlion.model.User;

public class UserDAOImpl implements UserDAO{

	public void saveUser(User user){
		System.out.println("save usering");
	}
}

UserService.java

package ml.orlion.service;

import ml.orlion.dao.UserDAO;
import ml.orlion.dao.impl.UserDAOImpl;
import ml.orlion.model.User;

public class UserService {

	private UserDAO userDAO = new UserDAOImpl();

	public UserDAO getUserDao() {

		return userDAO;
	}

	public void setUserDao(UserDAO userDAO) {
		this.userDAO = userDAO;
	}

	public void saveUser(User user){
		this.userDAO.saveUser(user);
	}
}

LogInterceptor.java

package ml.orlion.aop;

public class LogInterceptor {

	public void before(){
		System.out.println("before");
	}
}

beans.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: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">

	<bean id="logInterceptor" class="ml.orlion.aop.LogInterceptor">
	</bean>
  	<bean id="userDao" class="ml.orlion.dao.impl.UserDAOImpl">
 
  	</bean>
  	<bean id="userService" class="ml.orlion.service.UserService">
  		<property name="userDao" ref="userDao"/>
  	</bean>
  	<aop:config>
  		<aop:pointcut expression="execution(public * ml.orlion.service..*.add(..))"
  			id="servicePointcut" />
  		<aop:aspect id="logAspect" ref="logInterceptor">
  			<aop:before method="before" pointcut-ref="servicePointcut"/>
  		</aop:aspect>
  	</aop:config>
</beans>

测试:

BeanFactory appContext = new ClassPathXmlApplicationContext("beans.xml");
UserService userService = (UserService) appContext.getBean("userService");
userService.saveUser(new User());
时间: 2024-10-07 16:44:41

Spring(三)AOP面向切面编程的相关文章

spring入门-AOP 面向切面编程

AOP 面向切面编程 在日常开发中最后将业务逻辑定义在一个专门的service包下,而实现定义在service包下的impl包中, 服务接口以IXXXService形式,而服务实现就是XXXService,这就是规约设计 步骤: 1.E:\Users\WorkSpaces\KmwalletApp\spring\aop\test\HelloWorldService.java 继承(implements)xx接口 2.E:\Users\WorkSpaces\KmwalletApp\spring\ao

Spring:AOP, 面向切面编程

AOP概述 什么是AOP, 面向切面编程 AOP为Aspect Oriented Programming的缩写, 意为:面向切面编程, 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术. AOP是OOP的延续, 是函数式编程的一种衍生范型. 利用AOP可以对业务逻辑的各个部分进行隔离, 从而使得业务逻辑各部分之间的耦合度降低, 提高程序的可重用性, 同时提高了开发的效率. - 传统开发模型: 纵向的编程.  面向切面编程: 纵横配合的编程. AOP的作用及优势 作用: 在程序运行期

spring框架学习(三)——AOP( 面向切面编程)

AOP 即 Aspect Oriented Program 面向切面编程 首先,在面向切面编程的思想里面,把功能分为核心业务功能,和周边功能. 所谓的核心业务,比如登陆,增加数据,删除数据都叫核心业务 所谓的周边功能,比如性能统计,日志,事务管理等等 周边功能在Spring的面向切面编程AOP思想里,即被定义为切面 在面向切面编程AOP的思想里面,核心业务功能和切面功能分别独立进行开发 然后把切面功能和核心业务功能 "编织" 在一起,这就叫AOP 原理图 1. 功能分两大类,辅助功能和

Spring的AOP面向切面编程

什么是AOP? 1.AOP概念介绍 所谓AOP,即Aspect orientied program,就是面向方面(切面)的编程. 功能: 让关注点代码与业务代码分离! 关注点: 重复代码就叫做关注点: 业务代码: 核心业务的代码 业务代码与关注点代码分离,好处? --> 关注点代码写一次即可: -->开发者只需要关注核心业务: -->运行时期,执行核心业务代码时候动态植入关注点代码: [代理] 如何分离? 过程式/对象式/代理模式分离 AOP的好处是可以动态地添加和删除在切面上的逻辑而不

Spring之AOP(面向切面编程)_入门Demo

软件152 刘安民 AOP是OOP的延续,是Aspect Oriented Programming的缩写,意思是面向切面编程.AOP实际是GoF设计模式的延续,设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,AOP可以说也是这种目标的一种实现. 实现AOP的技术,主要分为两大类:一是采用动态代理技术,利用截取消息的方式,对该消息进行装饰,以取代原有对象行为的执行:二是采用静态植入的方式,引入特定的语法创建"方面",从而使得编译器可以在编译期间织入有关"方面"的代

java的动态代理的两种方式和spring的aop面向切面编程的对比

java动态代理的两种方式 使用动态代理的好处:可以进行类的功能的加强,同时减少耦合和代码的冗余,耦合的意思是不用吧加强的部分写到各个实现类里面,冗余的意思是如果对每个实现类加强的部分是一样的,通过一个代理类即可实现 基于jdk的动态代理 通过jdk中自带的Proxy类进行动态的代理,Proxy创建动态代理对象的时候要传入三个参数,第一个是classloader,第二个是interfaces,第三个是代理类实现的方法 要求:代理的是一个接口,必须至少有一个实现类 创建接口的代码: /** * a

【spring源码学习】spring的AOP面向切面编程的实现解析

一:Advice(通知)(1)定义在连接点做什么,为切面增强提供织入接口.在spring aop中主要描述围绕方法调用而注入的切面行为.(2)spring定义了几个时刻织入增强行为的接口??=>org.springframework.aop.BeforeAdvice???org.springframework.aop.MethodBeforeAdvice??=>org.springframework.aop.AfterAdvice???org.springframework.aop.After

spring:AOP面向切面编程(注解)03

使用注解写aop时最好使用环绕通知写 切面类: /** * 用于记录日志的工具类,它里面提供了公共的代码 */ @Component("logger") @Aspect //表示当前类是一个切面类 public class Logger { @Pointcut("execution(* cn.flypig666.service.impl.*.*(..))") private void pt1(){}; /** * 前置通知 */ @Before("pt1(

sprint.net(2) AOP面向切面编程,spring.net的环绕通知;Spring.net的AOP通知的四种类型

AOP 有点类似于我们MVC里面的Filter过滤器,例如在MVC里面,如果给一个Action上打一个标签,就可以在这个Action执行之前或者之后,额外的执行一个方法,这个就相当于是面向切面编程. 无侵入式的. (也就是在不改变原来的代码的情况下,来跳转到一个其他的方法,执行完毕后回到主方法..),但是spring.net的AOP更牛叉,只需要在xml里面配置,就可以了,不需要在方法上面打特性的标签,也不需要继承什么类(例如MVC的过滤器是继承了ActionFilterAttribute) 主