spring总结3

最新推荐文章于 2023-07-03 16:02:16 发布
最新推荐文章于 2023-07-03 16:02:16 发布
阅读量215 收藏
点赞数 1
分类专栏： java #spring框架 文章标签： java spring框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigseanihao/article/details/104100903
版权

一.spring AOP

1.什么是AOP

     Aop的全称是Aspect-Oriented Programing,即面向切面编程，是面向对象编程（OOP:Object-Oriented Programing）的一种延伸.AOP采取横向抽取机制，将分散在各个方法中的重复代码提取出来，然后在程序编译或运行时再讲这些提取出来的代码应用到需要执行的地方。

2.AOP术语

      Aspect(切面)、JoinPoint(连接点)、Pointcut(切入点)、Advice(通知增强处理)、Target Object(目标对象)、Proxy(代理)、Weaving(织入)。

3.AspectJ开发

      AspectJ是一个基于java语言的AOP框架。AspectJ实现AOP有两种方式：一种是基于XML的声明式AspectJ；另一种是基于注解的申明式AspectJ

(1)基于XML的声明式AspectJ

    常用元素的配置用例：

<!--定义切面Bean-->
<bean id="myAspect" class="com.ssm.aspectj.MyAspect"/>
<aop:config>
<!--配置切入点-->
<aop:pointcut id="myPointCut" expression="execution(* com.ssm.dao.impl.UserDaoImpl1.*(..))" />
    <!--配置切面-->
    <aop:aspect id="aspect" ref="myAspect">
    <!--配置通知-->
        <!--前置通知-->
        <aop:before method="myBefore" pointcut-ref="myPointCut"/>
        <!--后置通知-->
        <aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" 
            returning="returnVal" />
        <!--环绕通知-->
        <aop:around method="myAround" pointcut-ref="myPointCut" />
        <!--异常通知-->
        <aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
        <!--最终通知-->
        <aop:after method="myAfter" pointcut-ref="myPointCut" />
    </aop:aspect>
</aop:config> 
</beans>

  1.配置切面：

    使用<aop:aspect>元素，该元素会将一个一斤定义好的spring bean转换成切面bean,所以要在配置文件中先定义一个普通的spring bean。定义完成后，通过<aop:aspect>元素的ref属性即可引用该bean。属性有id，ref。

  2.配置切入点：

     使用<aop:pointcut>元素来定义的。当<aop:pointcut>元素作为<aop:config>元素的子元素定义时，表示该切入点是全局切入点，可以被多个切面所共享。当<aop:pointcut>元素作为<aop:aspect>元素的子元素定义时，表示该切入点只对当前切面有效。属性有id，expression（用于指定切入点关联的切入点表达式）execution(* com.ssm.dao.impl.UserDaoImpl1.*(..))，第一个*指目标方法的返回值类型代指所有类型；com.ssm.dao.impl.UserDaoImpl1.*代指需要被代理的目标方法，第二个*代指所有方法；（..）代指目标方法的任意参数。

3.配置通知

在<aop:aspect>的子元素配置5种常用通知,这些元素不支持在使用子元素，但在使用时可以指定一些属性：

属性名称描述
pointcut用于指定一个切入点表达式，spring将在匹配该表达式的连接点是植入该通知
pointcut-ref制定一个已经存在的切入点名称,如上面例子里面的myPoint.通常pointcut和pointcut-ref两个属性只需要使用其中之一就可以了
method指定一个方法名，指定将切面bean中的该方法转换为增强处理
throwing只对<after-throwing>元素有效，用于指定一个形参名，异常通知方法可以通过该形参名访问目标方法所抛出的异常
returning只对<after-retruning>元素有效，用于制定一个形参名，后置通知方法可以通过该形参访问目标方法的返回值

     以下为一个通过xml声明式的例子

  （1）创建一个接口   UserDao.java

package com.ssm.dao;

public interface UserDao1 {
	public void addUser();
	public void deleteUser();
}

（2）创建一个实现类   UserDaoImpl.java

package com.ssm.dao.impl;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import com.ssm.dao.UserDao1;
public class UserDaoImpl1 implements UserDao1{
    @Override
	public void addUser() {
		System.out.println("添加用户");	
	}
    @Override
	public void deleteUser() {
		System.out.println("删除用户");
	}

}

（3）创建一个切面类MyAspect.java

package com.ssm.aspectj;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
public class MyAspect {
	public void myBefore(JoinPoint joinPoint){
		System.out.print("前置通知：模拟执行权限检查...");
		System.out.print("目标类值："+joinPoint.getTarget());
		System.out.println("被植入增强处理的目标方法为："+joinPoint.getSignature()                    
        .getName());    
	}
	public void myAfterReturning(JoinPoint joinPoint)
	{
		System.out.print("后置通知：模拟记录日志...");
		System.out.println("被植入增强处理的目标方法 
        为："+joinPoint.getSignature().getName());
	}
	public Object myAround(ProceedingJoinPoint proceddingJoinPoint) throws Throwable
	{
		System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
		//执行当前目标方法
		Object obj=proceddingJoinPoint.proceed();
		//结束
		System.out.println("环绕结束：执行目标方法之后，模拟关闭事务");
		return obj;	
	}
	public void myAfterThrowing(JoinPoint joinPoint,Throwable e)
	{
		System.out.println("异常通知：出错了"+e.getMessage());
	}
	public void myAfter()
	{
		System.out.println("最终通知：模拟方法结束后释放资源...");
	}
}

（4）创建xml文件ApplicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="
   http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.2.xsd
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">
	<bean id="userDao" class="com.ssm.dao.impl.UserDaoImpl1"/>
	<bean id="myAspect" class="com.ssm.aspectj.MyAspect"/>
	<aop:config>
	<aop:pointcut id="myPointCut" expression="execution(* com.ssm.dao.impl.UserDaoImpl1.*(..))" />
		<aop:aspect id="aspect" ref="myAspect">
			
			<aop:before method="myBefore" pointcut-ref="myPointCut"/>
			<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="returnVal" />
			<aop:around method="myAround" pointcut-ref="myPointCut" />
			<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e" />
			<aop:after method="myAfter" pointcut-ref="myPointCut" />
		</aop:aspect>
	</aop:config> 
</beans>

(5)创建测试类TestXmlAspectJ,java

package com.ssm.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ssm.dao.UserDao1;

public class TestXmlAspectj {
	public static void main(String[] args) {
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("ApplicationContext3.xml");
		UserDao1 userDao=(UserDao1)applicationContext.getBean("userDao");
		userDao.addUser();
		
	}
}

结果是：

前置通知：模拟执行权限检查...目标类值：com.ssm.dao.impl.UserDaoImpl1@78b1cc93被植入增强处理的目标方法为：addUser
环绕开始：执行目标方法之前，模拟开启事务...
添加用户
最终通知：模拟方法结束后释放资源...
环绕结束：执行目标方法之后，模拟关闭事务
后置通知：模拟记录日志...被植入增强处理的目标方法为：addUser

（2）基于注解的声明式AspectJ

        注解介绍

注解名称描述
@Aspect用于定义一个切面
@Pointcut用于定义一个切入点表达式，在使用时还需定义 一个包含名字和任意参数的方法参数，来表示切入点名称，实际上，这个方法签名就是个返回值为void且方法体为空的普通方法。
@Before用于定义前置通知，通常要制定一个value属性值，该属性值用于制定一个切入点表达式（可以是已有的切入点，也可以是直接定义切入点表达式）
@AfterReturning用于定义后置通知，在使用时可以指定pointcut或value，returning属性，其中pointcut和value两个属性一样都指定切入点。returning属性值用于表示Advice()方法中定义与此同名的形参，该形参可用于访问目标方法的返回值
@Around用于定义环绕通知，在使用时需要制定一个value属性，该属性用于指定通知被植入的切入点
@AfterThrowing用于定义异常通知。在使用时可指定pointcut/value和throwing属性。其中pointcut/value与@AfterReturning一样。throwing属性值，用于指定一个形参名开表示Advice()方法中可以定义与此同名的形参，该形参可用于访问目标方法抛出的异常
@After用于定义最终通知，无论是否有异常，该通知都会执行，使用时需要制定一个value值，用于指定该通知Neo植入的切入点
@DeclareParents用于定义引介通知，（不需掌握）

例子：（用xml配置例子）

创建一个MyAspect.java

package com.ssm.aspectj;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect//将该类定义前面
@Component//由于该类在spring中时作为组件使用的
public class MyAspect1 {
    //定义切点表达式
	@Pointcut("execution(* com.ssm.dao.impl.UserDaoImpl1.*(..))")
	//使用一个返回值为void，方法体为空的方法来命名切入点
    public void myPointCut()
	{
		
	}
	
    //前置通知
    @Before(value = "myPointCut()")
	public void myBefore(JoinPoint joinPoint){
		System.out.print("前置通知：模拟执行权限检查...");
		System.out.print("目标类值："+joinPoint.getTarget());
		System.out.println("被植入增强处理的目标方法为："+joinPoint.getSignature().getName());
	}

	//后置通知
    @AfterReturning(value="myPointCut()")
	public void myAfterReturning(JoinPoint joinPoint)
	{
		System.out.print("后置通知：模拟记录日志...");
		System.out.println("被植入增强处理的目标方法为："+joinPoint.getSignature().getName());
	}

	//环绕通知
    @Around(value="myPointCut()")
	public Object myAround(ProceedingJoinPoint proceddingJoinPoint) throws Throwable
	{
		System.out.println("环绕开始：执行目标方法之前，模拟开启事务...");
		//执行当前目标方法
		Object obj=proceddingJoinPoint.proceed();
		//结束
		System.out.println("环绕结束：执行目标方法之后，模拟关闭事务");
		return obj;	
	}

	//异常通知
    @AfterThrowing(value="myPointCut()",throwing="e")
	public void myAfterThrowing(JoinPoint joinPoint,Throwable e)
	{
		System.out.println("异常通知：出错了"+e.getMessage());
	}

	//最终通知
    @After(value="myPointCut()")
	public void myAfter()
	{
		System.out.println("最终通知：模拟方法结束后释放资源...");
	}
}

在目标类UserDaoImpl.java(该类在上面有)中添加@repository("userDao")

package com.ssm.dao.impl;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import com.ssm.dao.UserDao1;
@repository("userDao")
public class UserDaoImpl1 implements UserDao1{
    @Override
	public void addUser() {
		System.out.println("添加用户");	
	}
    @Override
	public void deleteUser() {
		System.out.println("删除用户");
	}

}

创建applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="
   http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.2.xsd
   http://www.springframework.org/schema/aop 
   http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">
<!--指定需要少扫描的包，使注解生效-->
<context:component-scan base-package="com.ssm"/>
<!--启动基于注解的声明AspectJ支持-->
<aop:aspectj-autoproxy/>
   
</beans>

创建测试类TestAnnotation.java

package com.ssm.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ssm.dao.UserDao1;

public class TestXmlAspectj {
	public static void main(String[] args) {
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("ApplicationContext3.xml");//引号里要与你所建xml配置文件同名
		UserDao1 userDao=(UserDao1)applicationContext.getBean("userDao");
		userDao.addUser();
		
	}
}

结果与上面一样

bigseanihao
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
@AfterReturning配置
heirenheiren的专栏
07-03 3万+
AfterReturning和before，after，around不同是
Spring使用注解实现AOP
root_zhb的博客
01-12 323
Spring使用注解实现AOP
Spring AOP中定义切点（PointCut）和通知（Advice）
GarfieldEr007的专栏
09-21 1744
本文讨论一下Spring AOP编程中的两个关键问题，定义切点和定义通知，理解这两个问题能应付大部分AOP场景。 如果你还不熟悉AOP，请先看AOP基本原理，本文的例子也沿用了AOP基本原理中的例子。 切点表达式 切点的功能是指出切面的通知应该从哪里织入应用的执行流。切面只能织入公共方法。 在Spring AOP中，使用AspectJ的切点表达式语言定义切点其中excecution()
Aop切面编程详解
▶『 迟墨 』◀的博客
09-02 1556
1、什么叫做面向切面编程（aop）及其应用场景 对比面向对象编程（oop），oop中模块化的核心单位是类，而aop的核心单位是切面。切面使事务管理等关注点的模块化得到实现。比如跨多个类型和对象的事务管理。登录token校验、方法执行的权限校验（访问控制）、性能检测、事务管理、日志记录等2、切面编程的名词 切面（Aspetct）：切点和通知的关系称为切面 连接点（Join Point）：类中所有的方法都是连接点 切点（Point Cut）：缺少共性功能代码的方法 （切入点一定是连接点，连接点不一定是切入点）.
Spring AOP多个切面指定执行顺序
u012785397的博客
04-17 4037
spring aop多个切面默认执行顺序，如何指定其执行顺序，单个切面和多个切面下各通知方法执行顺序。
spring总结
07-26
spring最新总结，详细介绍spring的一些用法，注意事项。
spring3教程
03-08
总结，Spring3作为一款强大且全面的Java开发框架，为开发者提供了众多实用工具和优秀设计模式，旨在降低企业级应用的复杂度。通过深入学习和实践，我们可以利用Spring3的特性构建出高效、可维护的软件系统。
Spring总结.xmind
08-11
包含Spring简介，AOP，SpringMVC，集成JDBC，事务，ORM框架，Spring集成知识点总结，以思维导图的形式展示，xmind文件。
spring 总结md文档
02-24
spring入门笔记
spring知识总结.zip
08-25
在这个"spring知识总结.zip"压缩包中，我们可以期待找到一系列关于Spring框架及其相关技术的学习资料。 1. **Spring框架基础** - **依赖注入（Dependency Injection）**：Spring的核心特性之一，通过容器管理对象...
SpringAOP_切点表达式以及注解@Before、@After、@AfterReturning、@AfterThrowing、@Around
baidu_41924165的博客
09-23 6723
切入点表达式 作用 通过表达式的方式定位一个或多个具体的连接点。 语法细节 ①切入点表达式的语法格式 execution([权限修饰符] [返回值类型] [简单类名/全类名] [方法名]([参数列表])) ②举例说明 表达式 execution(* com.atguigu.spring.ArithmeticCalculator.*(..)) 含义 ArithmeticCalculator接口中.
spring学习总结-第三讲
WSYW126的博客
06-23 606
spring学习总结-第三讲
Spring 入门到实战
03-29
     Spring是一个轻量级的Java 开发框架 ，  它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。    主要包括：      IOC&DI、在Spring中配置Bean、自动装配、Bean之间的关系（依赖、继承）、Bean的作用域、使用外部属性文件、SpEL、管理Bean的生命周期、通过工厂方法配置Bean、通过注解配置Bean、注解方式AOP基础、前置通知、后置通知、返回通知、异常通知、环绕通知、切面的优先级、切点表达式、使用XML文件的方式配置AOP使用JdbcTemplate和JdbcDaoSupport、Spring的声明式事务、事务的属性、使用XML文件的方式配置事务整合应用
AOP(二)之AfterReturning增强处理
qq_40179479的博客
11-30 1万+
@AfterReturning @AfterReturning可修饰AfterReturning增强处理，AfterReturning增强处理将在目标方法正常完成后被织入。 使用@AfterReturning注解可指定如下四个属性，一般使用前三个。 pointcut/value:这两个属性的作用是一样的，它们都属于指定切入点对应的切入表达式。一样既可以是已有的切入点，也可直接定义切入点表达式。当...
三、Spring AOP （2）
m0_62639288的博客
07-03 192
一、基于代理类的AOP实现。
Spring AOP @Before @Around @After 等 advice 的执行顺序
淡然坊
03-08 2027
用过spring框架进行开发的人，多多少少会使用过它的AOP功能，都知道有@Before、@Around和@After等advice。最近，为了实现项目中的输出日志和权限控制这两个需求，我也使用到了AOP功能。我使用到了@Before、@Around这两个advice。但在，使用过程中，却对它们的执行顺序并不清楚。为了弄清楚在不同情况下，这些advice到底是以怎么样的一个顺序进行执行的，我作了个
Spring AOP(三)之AfterThrowing增强处理
热门推荐
owen_william的博客
03-06 6万+
使用@AfterThrowing注解可以修饰AfterThrowing增强处理，AfterThrowing增强处理主要用于处理程序中未处理的异常。使用@AfterThrowing注解时可指定如下的常用属性： 1)        pointcut/value:这两个属性的作用是一样的，它们都用于指定该切入点对应的切入表达式。一样既可是一个已有的切入点，也可以直接定义切入点表达式。当指定了point
@AfterThrowing(处理未处理的java异常)
IT_COOKIE_SAM的博客
02-21 1万+
正如题目所说,@afterthrowing是对于java异常的处理,但是你会说Java本身也有异常机制啊 error throwable exception runtimexception 并且也有一系列的自定义异常  也有对于异常的描述   譬如:e 是异常对象,我们可以使用e.getmessage()方法对异常进行描述.但是@afterThrowing是aop形式的异常描述,是在主类文件外部来
Spring3MVC注解(附实例).doc
最新发布
09-19
总结来说，本文档详细讲解了Spring 3 MVC中如何利用注解进行URL映射、控制器方法的标记，以及如何配置DispatcherServlet以支持注解处理器。通过阅读和实践这些示例，开发者可以更有效地利用Spring框架进行Web开发，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值