万次查询:
首先创建一个实现类:用来调用Mapper接口中的方法
package com.service;
import com.mapp.Mapperinter;
import com.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class ServiceImplement implements ServiceIm {
@Autowired
private Mapperinter mapperinter;
public List<User> selectall() {
return mapperinter.selectall();
}
}
Mapper接口:Mabits那边自动创建了Mapper接口的实现类,所以这里不用管,就暂时把这个接口看成实现类来用
package com.mapp;
import com.pojo.User;
import org.apache.ibatis.annotations.Select;
import java.util.List;
public interface Mapperinter {
@Select("select * from bank")
List<User> selectall();
}
创建一个关于junit的测试方法:
import com.config;
import com.pojo.User;
import com.service.ServiceImplement;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = config.class)
public class ServiceTest {
@Autowired
private ServiceImplement serviceImplement;
@Test
public void show(){
List<User> list=serviceImplement.selectall();
System.out.println(list);
}
}
测试之后没问题,那现在再加入环绕,即在代码执行的时候进行前后环绕
通知类:里面有环绕:
package com.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class aopadvice {
@Pointcut("execution(* com.service.ServiceImplement.selectall())")
public void pt(){}
@Around("aopadvice.pt()")
public void show(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
long start=System.currentTimeMillis();
for (int i=10000; i>1 ;i--){
proceedingJoinPoint.proceed();
}
long end= System.currentTimeMillis();
System.out.println("万次查询花费的时间:"+(end - start)+"ms");
}
}
流程:测试方法进行调用实现类,实现类调用Mapper接口,执行sql语句,环绕根据
execution()
来加,环绕方法中才开始正式的执行所要调用的方法,至于要不要返回这个方法的值全看你要不要写成返回类型为Object ,返回的话就是return,并且在测试类最终也接受的这个值,如果返回类型写成void
那么测试类那边就接收不到数值,返回类似null
等等
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
但是当你想要知道当前调用的是哪个方法时,就需要在环绕方法中添加一些调用,很简单,添加内容解释,具体看注释
@Around("aopadvice.pt()")
public void show(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//依次执行的签名信息,可以理解为封装了这次的执行过程
Signature signature =proceedingJoinPoint.getSignature();
//得到返回类型,即调用的类com.service.ServiceImplement
Class declaringType=signature.getDeclaringType();
//返回的类中的方法,即ServiceImplement类中的方法selectall()
String signatureName=signature.getName();
long start=System.currentTimeMillis();
for (int i=10000; i>1 ;i--){
proceedingJoinPoint.proceed();
}
long end= System.currentTimeMillis();
System.out.println("万次查询花费的时间:"+declaringType+"."+signatureName+"--------->>>"+(end - start)+"ms");
}
结果:
万次查询花费的时间:class com.service.ServiceImplement.selectall--------->>>1964ms
null
Process finished with exit code 0
百度网盘密码去空:
在环绕型中使用trim()方法
业务层接口与实现类:
package com.itjh.service;
public interface BaiduService {
public boolean openUrl(String username);
}
package com.itjh.service;
import com.itjh.pojo.Dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class BaiduServiceImpl implements BaiduService{
@Autowired
private Dao dao;
public boolean openUrl(String username) {
return dao.show(username);
}
}
数据层的接口和实现类:
package com.itjh.pojo;
public interface Dao {
public boolean show(String username);
}
package com.itjh.pojo;
import org.springframework.stereotype.Component;
@Component
public class DaoImple implements Dao{
@Override
public boolean show(String username) {
return "root".equals(username);
}
}
配置类:
package com.itjh.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@ComponentScan("com.itjh.*")
@EnableAspectJAutoProxy(exposeProxy = true)
public class SpringConfig {
}
通知类: 使用环绕通知方法,具体看注释
package com.itjh.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class Baiduwpaop {
@Pointcut("execution(boolean com.itjh.service.*Service.*(..))")
public void pt(){}
@Around(value = "pt()")
public Object Aroundexecut(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("小飞棍来喽~~~~~~~~~~~~~~");
//得到测试类传来的参数
Object[] args=joinPoint.getArgs();
//将参数进行一个一个剖析
for(int i=0;i<args.length;i++){
//用getClass()得到当前元素的类型,再调用equals(),
// 如果其类型是String类型,那他就是空格
if(args[i].getClass().equals(String.class)){
//将为空格的元素toString()打印出来,
// 调用trim()方法除掉空格
args[i]=args[i].toString().trim();
}
}
//将除掉空格的args传参进入正真调用的方法中,然后真正的方法进行完成后,
// 再将最终的 true 或者 false 传回来,再新创建一个布尔型收住它,然后打印
boolean o=(boolean)joinPoint.proceed(args);
System.out.println(o);
System.out.println("小飞棍又走喽~~~~~~~~~~~~~~");
//这里照常返回,但是这里返回的值,
// 测试类是否将他打印出来就全看测试类的意愿了,
return o;
}
}
结果:
小飞棍来喽~~~~~~~~~~~~~~
true
小飞棍又走喽~~~~~~~~~~~~~~
Process finished with exit code 0