万次查询耗时（纯注解sm与junit整合）和百度网盘密码去空

本文链接：https://blog.csdn.net/prisoneradvance/article/details/129485844

万次查询：

首先创建一个实现类：用来调用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