spring学习之aop(FactoryBean代理)

实验结构:

MyAspect.java

 1 package com.itheima.factorybean;
 2
 3 import org.aopalliance.intercept.MethodInterceptor;
 4 import org.aopalliance.intercept.MethodInvocation;
 5
 6 //切面类
 7 public class MyAspect implements MethodInterceptor {
 8
 9     @Override
10     public Object invoke(MethodInvocation arg0) throws Throwable {
11         // TODO Auto-generated method stub
12
13         //前增强
14         check_permission();
15         //执行目标方法
16         Object object=arg0.proceed();
17         //后增强
18         log();
19
20         return object;
21     }
22
23     public void check_permission() {
24         // TODO Auto-generated method stub
25
26         System.out.println("模拟检查权限");
27     }
28     public void log() {
29         // TODO Auto-generated method stub
30
31         System.out.println("模拟日志");
32     }
33 }

applicationContext..xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans
 5         http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
 6      <!-- 目标类 -->
 7     <bean id="userDao" class="com.itheima.jdk.UserDaoImpl"></bean>
 8     <!-- 切面类 -->
 9     <bean id="myAspect" class="com.itheima.factorybean.MyAspect"></bean>
10     <!-- 使用spring代理工厂定义一个名为userDaoProxy的代理对象 -->
11     <bean id="userDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
12         <property name="proxyInterfaces" value="com.itheima.jdk.UserDao"></property>
13         <property name="target" ref="userDao"></property>
14         <property name="interceptorNames" value="myAspect"></property>
15         <property name="proxyTargetClass" value="true"></property>
16     </bean>
17 <!--     指定代理实现的接口
18     指定目标对象
19     指定切面,织入环绕通知
20     指定代理方式,true:使用cglib,false(默认):使用jdk动态代理 -->
21
22 </beans>

ProxyFactoryBeanTest.java

 1 package com.itheima.factorybean;
 2
 3 import org.springframework.context.ApplicationContext;
 4 import org.springframework.context.support.ClassPathXmlApplicationContext;
 5
 6 import com.itheima.jdk.UserDao;
 7
 8 public class ProxyFactoryBeanTest {
 9
10     public static void main(String[] args) {
11         // TODO Auto-generated method stub
12         String xmlpathString="com/itheima/factorybean/applicationContext.xml";
13         ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlpathString);
14         //从spring容器中获得内容
15         UserDao userDao=(UserDao)applicationContext.getBean("userDaoProxy");
16         userDao.addUser();
17         userDao.deleteUser();
18     }
19
20 }

截图:

原文地址:https://www.cnblogs.com/2312947032zyk/p/11218284.html

时间: 2024-10-10 07:26:07

spring学习之aop(FactoryBean代理)的相关文章

spring学习(二) ———— AOP之AspectJ框架的使用

前面讲解了spring的特性之一,IOC(控制反转),因为有了IOC,所以我们都不需要自己new对象了,想要什么,spring就给什么.而今天要学习spring的第二个重点,AOP.一篇讲解不完,所以这篇文章主要介绍一下什么是AOP,如何去理解AOP.理解完之后,在spring中如何使用AspectJ AOP框架的.看得懂,写的出spring配置的那么就学的差不多了.加油.建议都自己手动实现一遍,这样才能更好的理解. --WH 一.什么是AOP? AOP:面向切面编程,采用横向抽取机制,取代了传

spring学习之aop(面向切面编程)

AOP术语学习: Aspect:切面,封装用于横向插入系统功能(事务,日志)的类 Joinpoint:连接点,在程序执行过程中的某个阶段点 Pointcut:切入点,切面与程序流程的交叉点,即那些需要处理的连接点. Advice:在定义好的切入点所要执行的程序代码,可以理解为切面类中的方法. Target Object:通知的对象,如果aop采用的是动态aop实现,该对象就是一个被代理对象. Proxy:代理,将通知应用到目标对象之后,被动态创建的对象. Weaving:织入,将切面代码插入到目

Spring学习笔记-AOP前传之动态代理

假设有如下需求: 写一个计算器类,里面包含加减乘除四个方法.在每个方法开始前打印出该方法开始的消息,在每个方法结束前打印出该方法结束的消息和计算的结果. 普通方法,先写一个借口,然后在接口里实现四个方法.在每个方法里加上要打印的语句.实现代码如下. ArithmeticCalculator接口 package com.spring.aop.helloworld; public interface ArithmeticCalculator { int add(int i, int j); int 

Spring学习笔记AOP(四)

鲁春利的工作笔记,好记性不如烂笔头 基于XML配置方式声明切面 Spring使用org.springframework.aop.Advisor接口表示切面的概念,Advisor表示只有一个通知(org.aopalliance.aop.Advice)和一个切入点(org.springframework.aop.Pointcut)的切面.Advisor可以使用<aop:config>标签下的<aop:advisor>标签定义. <aop:advisor id="标识&q

Spring学习之AOP

一.概述 在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型.利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率. 简而言之,aop的作用就是在不修改源码的情况下对程序进行增强,如权限校验,日志记录,性

Spring学习笔记AOP(二)

鲁春利的工作笔记,好记性不如烂笔头 要进行AOP编程,首先我们要在spring的配置文件中引入aop命名空间: 引入后AOP命名空间并启动对@AspectJ注解的支持(spring-context-aop-annotation.xml): <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance&q

Spring学习笔记----AOP编程

先用代码讲一下什么是传统的AOP(面向切面编程)编程 需求:实现一个简单的计算器,在每一步的运算前添加日志.最传统的方式如下: Calculator.java package cn.limbo.spring.aop.calculator; /** * Created by Limbo on 16/7/14. */ public interface Calculator { int add(int i , int j); int sub(int i , int j); int mul(int i

Spring学习之Aop的各种增强方法

AspectJ允许使用注解用于定义切面.切入点和增强处理,而Spring框架则可以识别并根据这些注解来生成AOP代理.Spring只是使用了和AspectJ 5一样的注解,但并没有使用AspectJ的编译器或者织入器,底层依然使用SpringAOP来实现,依然是在运行时动态生成AOP代理,因此不需要增加额外的编译,也不需要AspectJ的织入器支持.而AspectJ采用编译时增强,所以AspectJ需要使用自己的编译器来编译Java文件,还需要织入器. 为了启用Spring对@AspectJ切面

Spring学习之Aop的基本概念

转自:http://my.oschina.net/itblog/blog/209067 AOP的基本概念 AOP从运行的角度考虑程序的流程,提取业务处理过程的切面.AOP面向的是程序运行中的各个步骤,希望以更好的方式来组合业务逻辑的各个步骤.AOP框架并不与特定的代码耦合,AOP框架能处理程序执行中特定切入点,而不与具体某个类耦合(即在不污染某个类的情况下,处理这个类相关的切点).下面是一些AOP的一些术语: 切面(Aspect):业务流程运行的某个特定步骤,也就是应用运行过程的关注点,关注点通