`
acen.chen
  • 浏览: 157655 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

Spring AOP 简单入门示例

AOPSpringDAOBeanOOP 
阅读更多

分享一个自己写的最为简单的Spring AOP的应用，其实，本人也是学习Spring不久，只是把一些个人的理解分享下，供参考。可能很多人刚开始不太理解到底啥是AOP，其实它也是相对OOP来说的，类似OOP其实也是一种编程思想吧。本人暂且把Spring 中的AOP理解成一种方法的拦截器（可能有所片面，主要是方便理解）。

个人通俗理解，就好比你去自动取款机取钱，边上装了个摄像头在监视着。你取你的钱，不用管那摄像头干嘛，只是对于摄像头来说，已经把你取钱的这一过程记录了下来。你取钱的这一过程我们可以从OOP角度分析，而对于摄像头来说，就是从AOP角度去分析了。反映到我下面要讲的示例就是系统日志的记录。

 

我要讲的示例大致是这样的，从OOP角度分析，就是说现在有一个User对象，然后你要调用业务逻辑实现去保存（或者其他行为）这个User对象，或者说是做持久化操作，把User对象相关信息写进数据库。那么从AOP角度来看，就是在你进行保存对象这一行为发生的时候进行日志记录。就是说，你在进行业务操作的时候，不需要去关心系统背后到底做了啥，Spring AOP它已经帮你搞定了。

(图一、个人对于OOP与AOP在本人示例中的理解)

 

  上图说表示的东西是个人的理解理解，纵向为主业务逻辑这里表现为对User对象的持久化操作，横向为AOP实现，这里表现为系统日志记录。

 

以下是代码具体实现：（采用Spring2.5，Myeclipse6.5）

Java代码 复制代码
  1. （一）、从AOP角度分析：   
  2.   
  3. package org.wiki.spring.aspect;   
  4.   
  5. import org.aspectj.lang.JoinPoint;   
  6.   
  7. /**  
  8.  * 定义切面类，将系统中的横切性关注点模块化  
  9.  *   
  10.  * @author Wiki.M  
  11.  *   
  12.  */  
  13. public class Aspect {   
  14.   
  15.     /**  
  16.      * 定义advice，即切面类中方法具体实现， 这里主要是用于记录日志，只做简单处理。  
  17.      *   
  18.      * @param joinPoint,可以取得被拦截方法的一些信息  
  19.      */  
  20.     public void logging(JoinPoint joinPoint) {   
  21.         //得到被拦截方法参数，并打印   
  22.         Object[] args = joinPoint.getArgs();   
  23.         for (int i = 0; i < args.length; i++) {   
  24.             System.out.println("method arg" + i + " -- " + args[i]);   
  25.         }   
  26.            
  27.         //得到被拦截方法签名   
  28.         System.out.println(joinPoint.getSignature().getName());   
  29.            
  30.         //记录系统日志具体实现   
  31.         System.out.println("----logging-----");   
  32.     }   
  33. }   
  34.   
  35. （二）从DAO，数据持久化角度分析：   
  36. package org.wiki.spring.dao;     
  37.   
  38. import org.wiki.spring.domain.User;   
  39.   
  40. /**  
  41.  * 定义IUserDAO接口，目的是为了灵活实现UserDAO不同的操作。  
  42.  * @author Wiki.M  
  43.  *  
  44.  */  
  45. public interface IUserDAO {   
  46.        
  47.     public void addUser(User user);   
  48.        
  49.     public void deleteUser(int id);   
  50.        
  51.     public void updateUser(int id);   
  52. }   
  53.   
  54.   
  55. //==================================================   
  56.   
  57. package org.wiki.spring.dao;     
  58.   
  59. import org.wiki.spring.domain.User;   
  60.   
  61. /**  
  62.  * IUserDAO接口的具体实现，这里只做简单处理  
  63.  * @author Wiki.M  
  64.  *  
  65.  */  
  66. public class UserDAOImpl implements IUserDAO {   
  67.   
  68.     @Override  
  69.     public void addUser(User user) {   
  70.         System.out.println("----addUser----");   
  71.   
  72.     }   
  73.   
  74.     @Override  
  75.     public void deleteUser(int id) {   
  76.         System.out.println("----deleteUser----");   
  77.   
  78.     }   
  79.   
  80.     @Override  
  81.     public void updateUser(int id) {   
  82.         System.out.println("----updateUser----");   
  83.   
  84.     }   
  85. }   
  86.   
  87. （三）域模型分析   
  88. package org.wiki.spring.domain;     
  89.   
  90. /**  
  91.  * 领域模型User  
  92.  * @author Wiki.M  
  93.  *  
  94.  */  
  95. public class User {   
  96.        
  97.     private int id;   
  98.        
  99.     private String name;   
  100.        
  101.     private String password;   
  102.        
  103.     public int getId() {   
  104.         return id;   
  105.     }   
  106.   
  107.     public void setId(int id) {   
  108.         this.id = id;   
  109.     }   
  110.   
  111.     public String getName() {   
  112.         return name;   
  113.     }   
  114.        
  115.     public void setName(String name) {   
  116.         this.name = name;   
  117.     }   
  118.        
  119.     public String getPassword() {   
  120.         return password;   
  121.     }   
  122.        
  123.     public void setPassword(String password) {   
  124.         this.password = password;   
  125.     }   
  126.   
  127. }   
  128.   
  129. （四）、从业务层分析：   
  130. package org.wiki.spring.service;     
  131.   
  132. import org.wiki.spring.domain.User;   
  133.   
  134. /**  
  135.  * 定义User业务逻辑相关的一个接口，  
  136.  * 目的是为了在客户端自由调用接口实现  
  137.  * @author Wiki.M  
  138.  *  
  139.  */  
  140. public interface IUserService {   
  141.        
  142.    public void saveUser(User user);   
  143.       
  144.    public void deleteUser(int id);   
  145.       
  146.    public void updateUser(int id);    
  147. }   
  148.   
  149. //=========================================   
  150.   
  151.  package org.wiki.spring.service;     
  152.   
  153. import org.wiki.spring.dao.IUserDAO;   
  154. import org.wiki.spring.domain.User;   
  155.   
  156. /**  
  157.  * 业务逻辑接口IUserService的具体实现  
  158.  * @author Wiki.M  
  159.  *  
  160.  */  
  161. public class UserServiceImpl implements IUserService {   
  162.   
  163.     private IUserDAO userDAO;   
  164.        
  165.     public void setUserDAO(IUserDAO userDAO) {   
  166.         this.userDAO = userDAO;   
  167.     }   
  168.        
  169.     @Override  
  170.     public void deleteUser(int id) {   
  171.         userDAO.deleteUser(id);   
  172.     }   
  173.   
  174.     @Override  
  175.     public void saveUser(User user) {   
  176.         userDAO.addUser(user);   
  177.   
  178.     }   
  179.   
  180.     @Override  
  181.     public void updateUser(int id) {   
  182.         userDAO.updateUser(id);   
  183.     }   
  184.   
  185. }   
  186.   
  187. （五）从客户端调用分析：   
  188. package org.wiki.spring.client;     
  189.   
  190. import org.springframework.beans.factory.BeanFactory;   
  191. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  192. import org.wiki.spring.domain.User;   
  193. import org.wiki.spring.service.IUserService;   
  194.   
  195. public class Client {   
  196.        
  197.     /**  
  198.      * 客户端调用，用于测试  
  199.      * @param args  
  200.      */  
  201.     public static void main(String[] args){   
  202.            
  203.         BeanFactory factory = new ClassPathXmlApplicationContext("*.xml");   
  204.            
  205.         //得到UserService具体实现，用于操作业务逻辑   
  206.         IUserService userService = (IUserService)factory.getBean("userServiceImpl");   
  207.            
  208.         User user = new User();   
  209.         user.setId(1);   
  210.         user.setName("Wiki");   
  211.         user.setPassword("123");   
  212.            
  213.         //测试1，记录日志   
  214.         userService.saveUser(user);   
  215.            
  216.         //测试2，记录日志   
  217.         userService.deleteUser(1);   
  218.     }   
  219. }  
（一）、从AOP角度分析：

package org.wiki.spring.aspect;

import org.aspectj.lang.JoinPoint;

/**
 * 定义切面类，将系统中的横切性关注点模块化
 * 
 * @author Wiki.M
 * 
 */
public class Aspect {

    /**
	 * 定义advice，即切面类中方法具体实现， 这里主要是用于记录日志，只做简单处理。
	 * 
     * @param joinPoint,可以取得被拦截方法的一些信息
     */
	public void logging(JoinPoint joinPoint) {
		//得到被拦截方法参数，并打印
		Object[] args = joinPoint.getArgs();
		for (int i = 0; i < args.length; i++) {
			System.out.println("method arg" + i + " -- " + args[i]);
		}
		
		//得到被拦截方法签名
		System.out.println(joinPoint.getSignature().getName());
        
		//记录系统日志具体实现
		System.out.println("----logging-----");
	}
}

（二）从DAO，数据持久化角度分析：
package org.wiki.spring.dao;  

import org.wiki.spring.domain.User;

/**
 * 定义IUserDAO接口，目的是为了灵活实现UserDAO不同的操作。
 * @author Wiki.M
 *
 */
public interface IUserDAO {
	
	public void addUser(User user);
	
	public void deleteUser(int id);
	
	public void updateUser(int id);
}


//==================================================

package org.wiki.spring.dao;  

import org.wiki.spring.domain.User;

/**
 * IUserDAO接口的具体实现，这里只做简单处理
 * @author Wiki.M
 *
 */
public class UserDAOImpl implements IUserDAO {

	@Override
	public void addUser(User user) {
		System.out.println("----addUser----");

	}

	@Override
	public void deleteUser(int id) {
		System.out.println("----deleteUser----");

	}

	@Override
	public void updateUser(int id) {
		System.out.println("----updateUser----");

	}
}

（三）域模型分析
package org.wiki.spring.domain;  

/**
 * 领域模型User
 * @author Wiki.M
 *
 */
public class User {
	
	private int id;
	
	private String name;
	
	private String password;
	
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getPassword() {
		return password;
	}
	
	public void setPassword(String password) {
		this.password = password;
	}

}

（四）、从业务层分析：
package org.wiki.spring.service;  

import org.wiki.spring.domain.User;

/**
 * 定义User业务逻辑相关的一个接口，
 * 目的是为了在客户端自由调用接口实现
 * @author Wiki.M
 *
 */
public interface IUserService {
	
   public void saveUser(User user);
   
   public void deleteUser(int id);
   
   public void updateUser(int id); 
}

//=========================================

 package org.wiki.spring.service;  

import org.wiki.spring.dao.IUserDAO;
import org.wiki.spring.domain.User;

/**
 * 业务逻辑接口IUserService的具体实现
 * @author Wiki.M
 *
 */
public class UserServiceImpl implements IUserService {

	private IUserDAO userDAO;
	
	public void setUserDAO(IUserDAO userDAO) {
		this.userDAO = userDAO;
	}
	
	@Override
	public void deleteUser(int id) {
		userDAO.deleteUser(id);
	}

	@Override
	public void saveUser(User user) {
		userDAO.addUser(user);

	}

	@Override
	public void updateUser(int id) {
		userDAO.updateUser(id);
	}

}

（五）从客户端调用分析：
package org.wiki.spring.client;  

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.wiki.spring.domain.User;
import org.wiki.spring.service.IUserService;

public class Client {
	
	/**
	 * 客户端调用，用于测试
	 * @param args
	 */
	public static void main(String[] args){
		
		BeanFactory factory = new ClassPathXmlApplicationContext("*.xml");
		
		//得到UserService具体实现，用于操作业务逻辑
		IUserService userService = (IUserService)factory.getBean("userServiceImpl");
		
		User user = new User();
		user.setId(1);
		user.setName("Wiki");
		user.setPassword("123");
		
		//测试1，记录日志
		userService.saveUser(user);
		
		//测试2，记录日志
		userService.deleteUser(1);
	}
}

 

    Spring配置文件：

Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xmlns:aop="http://www.springframework.org/schema/aop"  
  6.     xmlns:tx="http://www.springframework.org/schema/tx"  
  7.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd   
  8.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd   
  9.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">  
  10.        
  11.     <!-- 配置UserDAOImpl -->  
  12.     <bean id="userDAO" class="org.wiki.spring.dao.UserDAOImpl"/>  
  13.        
  14.     <!-- 配置UserServiceImpl -->  
  15.     <bean id="userServiceImpl"  
  16.         class="org.wiki.spring.service.UserServiceImpl">  
  17.         <!-- 注入userDAO，实际为UserDAOImpl，即对数据持久化的具体实现 -->  
  18.         <property name="userDAO" ref="userDAO" />  
  19.     </bean>  
  20.        
  21.     <!-- 配置aspect切面类 -->  
  22.     <bean id="userAspect" class="org.wiki.spring.aspect.Aspect" />  
  23.   
  24.     <!-- 配置AOP -->  
  25.     <aop:config>  
  26.         <!-- 配置aspect切面类 -->  
  27.         <aop:aspect ref="userAspect">  
  28.             <!-- 配置pointcut,即切入点，对哪些类的哪些方法起到AOP的作用 -->  
  29.             <aop:pointcut id="userServiceMethods"  
  30.                 expression="execution(* org.wiki.spring.service.UserServiceImpl.*(..))" />      
  31.             <!-- 配置advice,即Aspect类中的logging()方法，这里采用在业务方法执行前进行拦截 -->  
  32.             <aop:before method="logging" pointcut-ref="userServiceMethods" />  
  33.         </aop:aspect>  
  34.            
  35.     </aop:config>  
  36. </beans>   
<?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"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
    
    <!-- 配置UserDAOImpl -->
	<bean id="userDAO" class="org.wiki.spring.dao.UserDAOImpl"/>
    
    <!-- 配置UserServiceImpl -->
	<bean id="userServiceImpl"
		class="org.wiki.spring.service.UserServiceImpl">
		<!-- 注入userDAO，实际为UserDAOImpl，即对数据持久化的具体实现 -->
		<property name="userDAO" ref="userDAO" />
	</bean>
	
    <!-- 配置aspect切面类 -->
	<bean id="userAspect" class="org.wiki.spring.aspect.Aspect" />

    <!-- 配置AOP -->
	<aop:config>
	    <!-- 配置aspect切面类 -->
		<aop:aspect ref="userAspect">
		    <!-- 配置pointcut,即切入点，对哪些类的哪些方法起到AOP的作用 -->
			<aop:pointcut id="userServiceMethods"
				expression="execution(* org.wiki.spring.service.UserServiceImpl.*(..))" />	
			<!-- 配置advice,即Aspect类中的logging()方法，这里采用在业务方法执行前进行拦截 -->
			<aop:before method="logging" pointcut-ref="userServiceMethods" />
		</aop:aspect>
		
	</aop:config>
</beans>

 

可能用到的Jar包： commons-logging.jar,  log4j.jar, spring.jar, aspectjrt.jar, aspectjweaver.jar

 

另附本人测试代码。

 

注：如使用Annotation方式最好请修改Aspect这个类的类名，命名的时候疏忽了，可能会更aspectjrt.jar中的类冲突。

  • 760489f5-1cbf-3bd5-a577-af2dab6f08d3-thumb
  • 大小: 23.6 KB
分享到：
| 如何让你的百万级SQL运行得更快
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    SpringAOP简单入门示例..pdf

    Spring AOP 简单入门示例 AOP（Aspect-Oriented Programming），即面向方面编程，是一种编程范式。AOP 是 OOP 的补充，它将系统中的横切性关注点模块化，并将其与业务逻辑分离。 在 Spring 中，AOP 是通过使用 ...

    spring AOP入门教程

    - **SpringAOP.doc**：可能是文档教程，包含了详细的步骤和示例代码。 - **SpringAOP_src.rar**：源代码示例，供你参考和实践。 - **readme.txt**：可能包含了关于这些资源的使用指南和注意事项。 通过学习和实践...

    Spring AOP简单demo

    以入门级的`advice`为例，我们可能有一个简单的日志切面： ```java @Aspect @Component public class LoggingAspect { @Pointcut("execution(* com.example.service.*.*(..))") public void serviceMethods() {} ...

    Spring AOP快速入门_源码

    本压缩包中的"Spring-AOP"文件可能包含了示例代码和jar包，可以用来进一步研究和实践Spring AOP的使用。通过阅读源码，你可以深入理解Spring AOP的内部实现机制，这对于成为一位精通Spring框架的开发者至关重要。

    Spring 入门案例——AOP

    本入门案例将帮助你理解并掌握Spring AOP的基本概念和使用方法。 在Spring AOP中，我们首先需要了解的是"切面"（Aspect）的概念。切面是封装了横切关注点的代码模块，它可以包含通知（Advice）、切点（Pointcut）和...

    SPRING AOP详细培训视频

    Spring AOP，全称Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为Java应用程序提供了声明式事务管理、日志记录、安全控制等跨切面关注点的功能。AOP允许开发者将一些通用功能如日志...

    Spring4.0从入门到精通AOP日志示例

    使用spring4.0进行用户日志的记录 这里带junit的测试跟main的测试 参考了 http://blog.csdn.net/oathevil/article/details/7288867 本代码中还包括了一个java自带注解的例子写的都非常易懂对于hellospring中第一位...

    Spring AOP 入门实例1

    以下是一个简单的Spring AOP入门实例步骤： 1. 首先，定义一个切面类，包含通知方法。例如，一个简单的日志切面： ```java @Aspect @Component public class LoggingAspect { @Before("execution(* com.example*...

    Spring -Aop入门

    ### Spring AOP 入门详解 #### 一、Spring AOP 概述 Spring AOP (Aspect Oriented Programming) 是一种面向切面编程的技术，在Spring框架中得到了良好的支持。通过这种方式，开发者可以更加灵活地组织代码，使得...

    Spring AOP入门及其实例讲解、下载

    **Spring AOP 入门及其实例讲解** 在软件开发中，面向切面编程（Aspect Oriented Programming，简称AOP）是一种编程范式，它旨在提高代码的可重用性，减少冗余，并将关注点分离。Spring框架是Java开发中的一个流行...

    spring aop 详细介绍

    5. **Spring AOP入门**： Spring AOP通过XML配置或者注解方式来实现AOP功能。在XML配置中，可以定义Bean、Advisor、Pointcut等元素。在注解方式下，可以使用`@Aspect`、`@Before`、`@After`、`@AfterReturning`、`@...

    springAOP-dome

    在这个名为"springAOP-dome"的实例中，我们将探讨如何利用Spring AOP实现一个简单的日志记录功能，以作为入门学习。 首先，了解AOP的基本概念是必要的。面向切面编程是一种编程范式，旨在解决程序中的横切关注点，...

    Spring AOP @AspectJ 入门实例

    在IT行业中，Spring框架是Java企业级应用开发的首选，而Spring AOP（面向切面编程）则是其核心特性之...同时，阅读博客文章（链接已给出）会提供更详细的解释和示例，帮助你更好地掌握Spring AOP和@AspectJ的实际应用。

    Spring aop.docx

    创建一个简单的Spring Boot AOP示例，包括以下几个步骤： 1. **Spring Boot项目生成**：使用Spring Initializr或者相关IDE插件，选择Spring Web模块，生成一个新的Spring Boot项目。 2. **添加依赖**：在`pom.xml`...

    spring2-aop入门实例教程

    ### Spring2-AOP入门实例教程知识点详解 #### 一、Spring框架概述 - **轻量级J2EE开发框架**：Spring是一个轻量级的Java应用框架，它为开发复杂的企业级应用提供了一种简化的方法。 - **发展历程**：自2002年发布...

    spring与maven简单入门示例2018年11月22日博客资源

    在这个"2018年11月22日博客资源"中，你将找到关于如何使用 Maven 来管理 Spring 入门程序的示例。下面我们将深入探讨这两个工具的使用和相互配合。 1. **Maven 的基本概念** - `pom.xml`：Maven 的核心配置文件，...

    Spring-mvc入门示例

    在本入门示例中，我们将深入理解 Spring MVC 的核心概念和关键组件，以便初学者能够快速上手。 1. **MVC 模式** MVC 模式是一种软件设计模式，用于分离应用程序的数据模型、用户界面和业务逻辑。Model（模型）处理...

    spring AOP 例子参考

    Spring AOP，全称为Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为Java应用程序提供了声明式...通过实践这些示例，你可以更好地理解如何在实际项目中应用Spring AOP来解决实际问题。

    Spring 入门AOP材料

    以上就是一个简单的Spring AOP入门介绍。通过学习和实践，你可以更好地理解如何在实际项目中利用AOP来提高代码的可维护性和灵活性。在后续的学习中，你还可以探索更高级的特性，如自定义通知类型和使用AspectJ的编织...

    spring的入门程序示例

    本示例旨在引导初学者入门Spring框架，通过一个简单的应用实例来理解其核心概念。 Spring框架的核心特性包括依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP）。依赖注入...

Magicbox
Global site tag (gtag.js) - Google Analytics