springday04(aop)

最新推荐文章于 2024-10-04 22:00:00 发布
最新推荐文章于 2024-10-04 22:00:00 发布
阅读量101 收藏
点赞数
分类专栏： ssm spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yygyj/article/details/113455679
版权

Spring AOP 注解 权限管理 事务控制 切面编程
关键词由CSDN通过智能技术生成

aop的注解方式实现
spring也支持注解方式实现aop，相对于配置文件的方式，注解配置更加的轻量级，配置修改更加的方便，是目前最流行的方式。
a.开启aop的注解配置方式

 <!--注解方式配置aop开关  -->
	 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

b.将指定的类标志为一个切面,并配置id

@Aspect
public class FirstAspect {
	@Pointcut("execution(* cn.tedu.service..*.*(..))")
	public void mx(){
		
	}

c.配置通知 指定切入点规则
前置通知 @Before
环绕通知@Around
后置通知@AfterReturning
异常通知@AftereThrowing
最终通知@After在这里插入图片描述
代码实现：

package cn.tedu.aspect;
//切面类
import java.lang.reflect.Method;
import java.util.Arrays;

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.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import cn.tedu.domain.User;

@Component
@Aspect
public class FirstAspect {
	@Pointcut("execution(* cn.tedu.service..*.*(..))")
	public void mx(){
		
	}
	/**
	 * 前置
	 * @param jp
	 */
	@Before("mx()")
	public void before(JoinPoint jp){
		System.out.println("前置通知1..");
		//获取目标对象
		Object targetObj=jp.getTarget();
		System.out.println(targetObj);
		//获取目标方法
		MethodSignature msig=(MethodSignature) jp.getSignature();
		Method m=msig.getMethod();
		System.out.println(m.getName());
		System.out.println(m.getReturnType());
		System.out.println(Arrays.asList(m.getParameterTypes()));
	}
	/**
	 * 环绕
	 * @param pjp
	 * @return
	 * @throws Throwable
	 */
	@Around("mx()")
	public Object around(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("环绕通知1...before..");
		//执行目标方法
		Object retuObj=pjp.proceed();
		System.out.println("环绕通知1...after..");
		return retuObj;
		//return new User(33,"zsf","sf","dsf");//慎用，这里不是service层
	}
	/**
	 * 后置
	 */
	@AfterReturning(value="mx()",returning="reObj")
	public void afterReturning(JoinPoint jp,Object reObj){
		System.out.println("后置通知1..."+reObj);
		Object obj=jp.getTarget();
		System.out.println(obj);
		MethodSignature signature=(MethodSignature) jp.getSignature();
		Method method=signature.getMethod();
		System.out.println(method.getName());
		System.out.println(method.getReturnType());
		System.out.println(Arrays.asList(method.getParameterTypes()));
	}
	/**
	 * 异常
	 */
	@AfterThrowing(value="mx()",throwing="e")
	public void afterThrowing(JoinPoint jp,Throwable e){
		System.out.println("异常通知1..."+e.getMessage());
	}
	/**
	 * 最终
	 */
	@After("mx()")
	public void after(){
		System.out.println("最终通知1...");
	}
}

案例aop:
1.异常信息收集
有异常抛出，根据异常信息记录日志
代码实现：

package cn.tedu.aspect;



import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class FirstAspect {
	@Pointcut("execution(* cn.tedu.service..*.*(..))")
	public void mx(){
		
	}
	private Logger logger=Logger.getLogger(FirstAspect.class);
	@AfterThrowing(value="mx()",throwing="e")
	public void afterThrowing(JoinPoint jp,Throwable e){
		Object obj=jp.getTarget();
		MethodSignature signature=(MethodSignature) jp.getSignature();
		logger.error("在访问["+obj+"]的["+signature.getMethod().getName()+"]方法时抛出了["+e.getMessage()+"]异常");
	}
}


package cn.tedu.service;

import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService{
	@Override
	public void add(){
		System.out.println("增加用户");
		//int i=1/0;
	}
}


package cn.tedu.web;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import cn.tedu.service.UserService;
@Controller
public class UserServlet {
	@Autowired
	UserService userService=null;
	public void addUser(){
		userService.add();
	}
}


package cn.tedu.test;

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

import cn.tedu.web.UserServlet;

public class test01 {
	@Test
	public void test01(){
		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
		UserServlet userServlet=(UserServlet) context.getBean("userServlet");
		userServlet.addUser();
	}
}

配置：

 <!-- 配置ioc -->
	 <context:component-scan base-package="cn.tedu.web"></context:component-scan>
	 <context:component-scan base-package="cn.tedu.service"></context:component-scan>
	 <context:component-scan base-package="cn.tedu.dao"></context:component-scan>
	 <context:component-scan base-package="cn.tedu.aspect"></context:component-scan>
	 <!--注解方式配置aop开关  -->
	 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

2.方法执行所用的时间

package cn.tedu.aspect;



import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class FirstAspect2 {
	@Pointcut("execution(* cn.tedu.service..*.*(..))")
	public void mx(){
		
	}
	@Around(value="mx()")
	public void around(ProceedingJoinPoint pjp) throws Throwable{
		long start=System.currentTimeMillis();
		Object obj=pjp.proceed();
		long end=System.currentTimeMillis();
		long useTime=end-start;
		System.out.println("调用["+pjp.getTarget()+"]的["+pjp.getSignature().getName()+"]所用时间为["+useTime+"]");
	}
}


package cn.tedu.service;

import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService{
	@Override
	public void add(){
		System.out.println("增加用户");
		//int i=1/0;
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

3.实现事务控制（原代码在SpringDay04_03aop_demo项目中）
通过aop实现事务控制，通过注解来标识方法是否需要事务
在切面中通过判断目标方法是否具有事务注解决定是否执行事务
通过事务管理器管理事务防止耦合
代码实现

package cn.tedu.aspect;



import java.lang.reflect.Method;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import cn.tedu.anno.Trans;
import cn.tedu.util.TransactionManager;
@Component
@Aspect
public class TransAspect {
	
	
	@Around(value="execution(* cn.tedu.service..*.*(..))")
	public Object around(ProceedingJoinPoint pjp) throws Throwable{
		//获取目标对象
		Object target=pjp.getTarget();
		//获取当前方法(接口上的方法)----注解在实现类的方法上
		MethodSignature signature=(MethodSignature) pjp.getSignature();
		Method method=signature.getMethod();
		//在目标身上获取该方法（实现类上的方法）
		Method instance_method=target.getClass().getMethod(method.getName(), method.getParameterTypes());
		//判断当前方法上有没有@Tran修饰
		if(method.isAnnotationPresent(Trans.class)||instance_method.isAnnotationPresent(Trans.class)){
			try {
				TransactionManager.startTran();
				Object reObj=pjp.proceed();
				TransactionManager.commitTran();
				return reObj;
			} catch (Exception e) {
				TransactionManager.rollbacktTran();
				throw e;
			}finally{
				TransactionManager.release();
			}
		}else{//没有注解说明不需要事务，不管理事务
			try{
				Object reObj=pjp.proceed();
				return reObj;
			}finally{
				TransactionManager.release();
			}
		}
	}
	
}


package cn.tedu.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;


import org.springframework.stereotype.Repository;


import cn.tedu.domain.User;
import cn.tedu.util.JDBCUtils;
import cn.tedu.util.TransactionManager;

@Repository
public class UserDaoImpl implements UserDao{
	
	@Override
	public void addUser(User user) {
		Connection conn=null;
		PreparedStatement ps=null;
		ResultSet rs=null;
		//注册数据库驱动
		//获取数据库连接
		try {
			conn=TransactionManager.getConn();
			ps=conn.prepareStatement("insert into user values(?,?,?)");
			ps.setInt(1, user.getId());
			ps.setString(2, user.getName());
			ps.setInt(3, user.getAge());
			ps.executeUpdate();
			//需求：报异常不想让他传入数据库，可以通过事务处理
			//int i=1/0;
		} catch (SQLException e) {
			throw new RuntimeException(e);
		}finally{
			JDBCUtils.close(null, ps, rs);
		}
		
	}

	@Override
	public void delUser(int id) {
		Connection conn=null;
		PreparedStatement ps=null;
		try {
			conn=TransactionManager.getConn();
			ps=conn.prepareStatement("delete from user where id=?");
			ps.setInt(1,id);
			ps.executeUpdate();
			//需求：报异常不想让他传入数据库，可以通过事务处理
			//int i=1/0;
		} catch (SQLException e) {
			throw new RuntimeException(e);
		}finally{
			JDBCUtils.close(null, ps,null);
		}
	}

	@Override
	public User queryUser(int id) {
		Connection conn=null;
		PreparedStatement ps=null;
		ResultSet rs=null;
		//注册数据库驱动
		//获取数据库连接
		try {
			conn=TransactionManager.getConn();
			ps=conn.prepareStatement("select * from user where id=?");
			ps.setInt(1, id);
			rs=ps.executeQuery();
			User user=null;
			if(rs.next()){
				user=new User();
				user.setId(rs.getInt("id"));
				user.setName(rs.getString("name"));
				user.setAge(rs.getInt("age"));
			}
			return user;
			//需求：报异常不想让他传入数据库，可以通过事务处理
			//int i=1/0;
		} catch (SQLException e) {
			throw new RuntimeException(e);
		}finally{
			JDBCUtils.close(null, ps, rs);
		}
		
	}
	
}


package cn.tedu.service;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cn.tedu.anno.Trans;
import cn.tedu.dao.UserDao;
import cn.tedu.domain.User;

@Service
public class UserServiceImpl implements UserService{
	@Autowired
	UserDao userDao=null;
	@Trans
	@Override
	public void addUser(User user){
			userDao.addUser(user);
	}
	@Override
	public void delUser(int id) {
		userDao.delUser(id);
	}
	@Override
	public User queryUser(int id) {
		return userDao.queryUser(id);
	}
}


package cn.tedu.util;

import java.sql.Connection;

//事务管理提交回滚
public class TransactionManager {
	
	private static Connection conn=JDBCUtils.getConn();
	private TransactionManager(){
		
	}
	
	public static void startTran(){
		try {
			conn.setAutoCommit(false);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		
	} 
	
	public static void commitTran(){
		try {
			conn.commit();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		
	} 
	
	public static void rollbacktTran(){
		try {
			conn.rollback();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		
	} 
	public static Connection getConn(){
		return conn;
	}
	public static void release(){
		JDBCUtils.close(conn, null, null);
	}
}


package cn.tedu.util;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class JDBCUtils {
	private JDBCUtils(){
		
	}
	private static DataSource datasource=new ComboPooledDataSource();
	public static Connection getConn(){
		
			try {
				return datasource.getConnection();
			} catch (SQLException e) {
				throw new RuntimeException(e); 
			}
		
	}
	public static void close(Connection conn,Statement stat,ResultSet rs){
		if(rs!=null){
			try {
				rs.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}finally{
				rs=null;
			}
		}
		if(stat!=null){
			try {
				stat.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}finally{
				stat=null;
			}
		}
		if(conn!=null){
			try {
				conn.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}finally{
				conn=null;
			}
		}
	} 
}


package cn.tedu.web;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import cn.tedu.domain.User;
import cn.tedu.service.UserService;
@Controller
public class UserServlet {
	@Autowired
	UserService userService=null;
	public void addUser(User user){
		userService.addUser(user);
	}
	public void delUser(int id){
		userService.delUser(id);
	}
	public User queryUser(int id){
		return userService.queryUser(id);
	}
}

有线程问题存在（多个线程、同一个共享资源、至少有一个在写，三者有一个都会造成线程问题）
加锁会降低效率所以使用本地线程变量解决此问题
在这里插入图片描述
在这里插入图片描述

package cn.tedu.demo;
//本地线程变量测试
public class Demo1 {
	private static ThreadLocal<String> tl=new ThreadLocal<String>();
	public static void main(String[] args){
		tl.set("hello from main~");//向当前线程内部内部map中存储了键值对
		A();
	}
	public static void A(){
		B();
	}
	public static void B(){
		C();
	}
	public static void C(){
		D();
	}
	public static void D(){
		System.out.println("d..."+tl.get());//从当前线程内部map中取值
		tl.remove();
		
	}
}

修改上述事务项目（SpringDay04_03aop_demo项目）

package cn.tedu.util;

import java.sql.Connection;

//事务管理提交回滚（改进）
public class TransactionManager {
	
	//private static Connection conn=JDBCUtils.getConn();
	private static ThreadLocal<Connection> tl=new ThreadLocal<Connection>(){
		protected Connection initialValue(){
			return JDBCUtils.getConn();
		};
	};
	
	private TransactionManager(){
		
	}
	
	public static void startTran(){
		try {
			tl.get().setAutoCommit(false);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		
	} 
	
	public static void commitTran(){
		try {
			tl.get().commit();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		
	} 
	
	public static void rollbacktTran(){
		try {
			tl.get().rollback();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		
	} 
	public static Connection getConn(){
		return tl.get();
	}
	public static void release(){
		JDBCUtils.close(tl.get(), null, null);
		tl.remove();
	}
}

4.通过aop进行权限管理
通过aop来进行权限管理，通过自定义注解声明业务方法是否需要进行权限控制，通过注解上属性声明需要什么样的权限
代码实现：

package cn.tedu.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import cn.tedu.enumration.PrivEnum;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PrivAnno {
	PrivEnum[] value();
}


package cn.tedu.aspect;



import java.lang.reflect.Method;
import java.util.Arrays;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import cn.tedu.anno.PrivAnno;
import cn.tedu.enumration.PrivEnum;
import cn.tedu.test.Test01;
@Component
@Aspect
public class PrivAspect {
	@Around("execution(* cn.tedu.service..*.*(..))")
	public Object around(ProceedingJoinPoint pjp) throws Throwable{
		Object obj=pjp.getTarget();
		MethodSignature signature=(MethodSignature) pjp.getSignature();
		Method method=signature.getMethod();//接口上的方法
		Method instMethod=obj.getClass().getMethod(method.getName(), method.getParameterTypes());
		if(instMethod.isAnnotationPresent(PrivAnno.class)){
			PrivAnno pano=instMethod.getAnnotation(PrivAnno.class);
			PrivEnum[] privs=pano.value();
			//.判断是否有权限
			if(Arrays.asList(privs).contains(Test01.tl.get())){
				return pjp.proceed();
			}else{
				throw new RuntimeException("权限不够");
			}
		}else{
			return pjp.proceed();
		}
	}
}


package cn.tedu.enumration;

public enum PrivEnum {
	ADMIN,SUPERADMIN,USER;
}


package cn.tedu.service;

import org.springframework.stereotype.Service;

import cn.tedu.anno.PrivAnno;
import cn.tedu.enumration.PrivEnum;

@Service
public class UserServiceImpl implements UserService{
	@PrivAnno({PrivEnum.ADMIN,PrivEnum.SUPERADMIN})
	@Override
	public void add(){
		System.out.println("增加用户...");
	}
	@PrivAnno({PrivEnum.SUPERADMIN})
	@Override
	public void del() {
		System.out.println("删除用户...");
	}
	@Override
	public void queryUser() {
		System.out.println("查询用户...");
		
	}
}


package cn.tedu.web;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import cn.tedu.service.UserService;
@Controller
public class UserServlet {
	@Autowired
	UserService userService=null;
	public void addUser(){
		userService.add();
	}
	public void delUser(){
		userService.del();
	}
	public void queryUser() {
		userService.queryUser();
	}
	
}


package cn.tedu.test;

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

import cn.tedu.enumration.PrivEnum;
import cn.tedu.web.UserServlet;

public class Test01 {
	public static ThreadLocal<PrivEnum> tl=new ThreadLocal<PrivEnum>();
	@Test
	public void test00(){
		new Thread(new Runnable() {
			@Override
			public void run() {
				tl.set(PrivEnum.SUPERADMIN);
				ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
				UserServlet userServlet=(UserServlet) context.getBean("userServlet");
				userServlet.addUser();
			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				tl.set(PrivEnum.ADMIN);
				ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
				UserServlet userServlet=(UserServlet) context.getBean("userServlet");
				userServlet.delUser();
			}
		}).start();
		new Thread(new Runnable() {
			@Override
			public void run() {
				tl.set(PrivEnum.USER);
				ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
				UserServlet userServlet=(UserServlet) context.getBean("userServlet");
				userServlet.addUser();
			}
		}).start();
		
		
	}
	
	
	
	//public static PrivEnum role=PrivEnum.ADMIN;
	@Test
	public void test01(){
		
		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
		UserServlet userServlet=(UserServlet) context.getBean("userServlet");
		userServlet.addUser();
		
	}
	@Test
	public void test02(){
		
		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
		UserServlet userServlet=(UserServlet) context.getBean("userServlet");
		userServlet.delUser();
	}
	@Test
	public void test03(){
		
		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
		UserServlet userServlet=(UserServlet) context.getBean("userServlet");
		userServlet.queryUser();
	}
}
快乐咸鱼Y
关注
专栏目录
spring_day04
01-10
PlatformTransactionManager接口（平台事务管理器接口），不管使用哪种方式管理事务，这个类必须配置的！！
springday02
07-09
在实际操作中，你可能还会遇到如 Bean 的生命周期管理、AOP（面向切面编程）、Spring MVC 等其他Spring相关的概念，这些都是Spring框架中不可或缺的部分。通过不断地学习和实践，你将在IT领域建立起坚实的基础。
Spring_day03、Spring_day04问题记录
Json Yao的博客
08-30 216
Spring_day03问题记录 1.读properties文件用EL表达式？ Spring中是可以在xml中使用el表达式读取 .properties 文件的。（原理未知） 2.private Account ad;要set方法才能注入？ 需要属性注入，就需要property注入，就需要set方法。 3..匿名类访问外部要加final? Java为了避免数据不...
SpringDay03Aop面向切面程序
Hpeacheng的博客
11-07 132
【1】Aop（Aspect Oriented Programming）面向切面编程，基层原理就是利用动态代理的方法 【2】动态代理有基于接口的代理，有基于子类的动态代理。动态代理中被代理的对象中的党法就是切面的连接点，而切入点就是我们使用动态代理对被代理对象中的方法增强之后的方法。所有方法都可以看作是连接点，但是只有被增强过的方法才是切入点。 【3】在Spring中，动态代理的方法都已经被Spring框架解决了，我们来学习下它怎么用。 【4】首先Spring中的AOP也是提供了xml配置的方法和注解方
SpringDay04使用注解实现Aop
Mark_able
11-17 121
使用注解实现Aop 步骤①、首先在配置文件中加载 <!-- 使用注解实现IOC --> <context:component-scan base-package="com.web"/> <!-- 使用注解实现AOP --> <aop:aspectj-autoproxy /> 然后让切面类受spring容器所管理也就是 package...
SpringDay04
weixin_51556519的博客
07-19 198
transaction
Springday03 AOP、Spring声明式事务、Spring编程式事务
weixin_44504809的博客
05-12 283
Springday03 AOP、Spring声明式事务、Spring编程式事务
57 springDay04
qq_38664094的博客
04-27 166
1、spring中的JdbcTemplate JdbcTemplate的作用： 它就是用于和数据库交互的，实现对表的CRUD操作 如何创建该对象： 对象中的常用方法： 2、作业： spring基于AOP的事务控制 3、spring中的事务控制 基于XML的 基于注解的 -----------------------------------------------------------------...
【SpringDay03之AOP】
qq_42000760的博客
03-10 140
动态代理 在学习Spring的时候，我们知道Spring主要有两大思想，一个是IoC，另一个就是AOP，对于IoC，依赖注入就不用多说了，而对于Spring的核心AOP来说，我们不但要知道怎么通过AOP来满足的我们的功能，我们更需要学习的是其底层是怎么样的一个原理，而AOP的原理就是java的动态代理机制。 动态代理的特点 字节码随用随创建，随用随加载。 它与静态代理的区别也在于此。因为静态代理是...
SpringDay04通过配置文件实现Aop
Mark_able
11-17 82
配置文件实现Aop只需在配置文件中加入本段代码 <!-- 使用配置文件实现AOP --> <aop:config> <aop:aspect ref="logInterceptor" > <aop:pointcut expression="execution(public * com.web.service.impl.*.*(..))" id=...
SpringDay3
03-27
在"SpringDay3"的学习主题中，我们将专注于如何使用注解来实现AOP，这种方式简化了配置，使得代码更加简洁且易于理解。以下是关于Spring注解驱动的AOP开发的关键知识点： 1. **注解基础**： - `@Aspect`：这是定义...
SpringDay2
03-27
总结起来，SpringDay2的学习涵盖了Bean的注解扫描，如何通过注解简化Bean的定义和管理，以及如何利用AOP实现模块化的关注点分离。这些知识是Spring开发中的基础，理解并掌握它们对于提升Java应用的开发效率和质量至...
springday02-2
07-09
标题“springday02-2”暗示了这是一个关于Spring框架的第二阶段学习资源，主要涉及如何使用Spring来实现项目的分层架构。在这个项目中，我们将深入理解Spring在构建实际应用程序中的核心作用，以及如何通过它来实现...
springday03(aop)
yygyj的博客
02-01 99
相关jar包aopalliance、aspectjrt、aspectweaver下载 网址： https://repo1.maven.org/maven2/org/aspectj/aspectjrt/1.7.4/ 继承 装饰者 静态代理基于Java 动态代理基于Java 动态代理cglib 代码实现：看看即可 package cn.tedu.test; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method;
毕业设计_基于springboot+layui+mybatisPlus的中小型仓库物流管理系统源码+SQL+教程+可运行】41004
最新发布
pingguocu3的博客
10-04 748
毕业设计--课程设计--springboot--java 登录管理员账号：system 密码：123456 验证码输入：注意验证码字母要大写。启动项目后运行http://locahost:8080跳转到登录界面即可。后端：springboot、mybatis-plus、shiro。application.yml文件中的数据库连接信息。运行sql目录下的warehouse.sql文件。1.基础管理：商品管理、客户管理、供应商管理；2.物流管理：进货管理、发货管理、交付管理...
springboot+neo4j demo
极客栈
09-27 671
这个简单的示例展示了如何在Spring Boot应用中集成Neo4j，包括创建节点实体、使用Neo4j仓库接口以及创建一个简单的REST控制器。这个示例可以作为开发者学习和实践Spring Boot与Neo4j集成的起点。以下是一个简单的Spring Boot与Neo4j集成的示例代码。
SpringBoot--为什么Controller是串行的？怎样才能并行？
IT利刃出鞘的博客
09-29 692
本文介绍SpringBoot为什么Controller是串行的？在什么场景下才能并行执行？
Spring注解配置与Junit整合教程
- **拷贝必备jar包**：在基于注解配置的项目中，除了Spring的核心库，还需要包含AOP（面向切面编程）的jar包，以便支持注解的动态代理功能。 - **创建XML配置文件**：虽然采用注解配置，但仍然需要一个XML文件来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值