SSM-Spring#

1
src/main/java/你的项目根包
2
├── bean          // 实体类：Car、Dog、Person、User 等
3
├── config        // Spring 配置类（替代XML配置文件）
4
├── controller    // 控制层 = 升级版 Servlet
5
├── service       // 业务层
6
├── dao           // 持久层
7
├── factory       // 自定义 FactoryBean 工厂类
8
├── condition     // 自定义条件装配类
9
└── 主启动类       // Spring 项目入口，容器启动类

1
// 1. 启动 Spring 容器
2
ConfigurableApplicationContext ioc = SpringApplication.run(主启动类.class, args);

1
public class DynamicProxy {
2
    public static void main(String[] args) { }
3
    public static Object getProxyInstance(Object target){
4

5
        return Proxy.newProxyInstance(
6
                target.getClass().getClassLoader(),//参数1
7
                target.getClass().getInterfaces(),//参数2
8
                (proxy, method, args) -> {
9
                    LogUtils.logStart(method.getName(), args);
10
                    Object result = null;
11
                    try {
12
                        result = method.invoke(target, args);
13
                    } catch (Exception e) {
14
                        LogUtils.logException(method.getName(), e);
15

16
                    } finally {
17
                        LogUtils.logResult(method.getName(), result);
18
                        LogUtils.logEnd(method.getName(), args);
19
                        return result;
20
                    }
21
                }//参数3
22
        );
23
    }
24
}

1
public class MathTest {
2
    @Test
3
    public void test() {
4

5
        MathCalculator Proxy = (MathCalculator) DynamicProxy.getProxyInstance(new MyCalculator());
6
        int add = Proxy.add(1, 2);
7
        System.out.println(add);
8
        System.out.println("========================");
9
        int div = Proxy.div(10, 0);
10
        System.out.println(div);
11
    }
12
}

1
@Component
2
@Aspect
3
public class LogAspect {
4

5
    @Before("execution(int org.springdata.spring02aop.Calculator.MathCalculator.*(int,int))")
6
    public void logStart(){
7
        System.out.println("logStart...");
8
    }
9

10
    @After("execution(int org.springdata.spring02aop.Calculator.MathCalculator.*(int,int))")
11
    public void logReturn(){
12
        System.out.println("logReturn...");
13
    }
14

15
    @AfterThrowing("execution(int org.springdata.spring02aop.Calculator.MathCalculator.*(int,int))")
16
    public void logException() {
17
        System.out.println("logException...");
18
    }
19

20
    @AfterReturning("execution(int org.springdata.spring02aop.Calculator.MathCalculator.*(int,int))")
21
    public void logEnd(){
22
        System.out.println("logEnd...");
23
    }

1
        @Before("execution(int *(int,int))")
2
        public void logstart(JoinPoint joinPoint){//这个joinPoint就代表连接点,连接点里有当前方法的全部信息
3
            //Signature signature = joinPoint.getSignature();//拿到方法全签名
4
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();//转换成MethodSignature,因为有更多的方                                                                                  法可以调用
5
            String methodName = signature.getName();//拿到方法名
6
            Object[] args = joinPoint.getArgs();//参数值
7
            System.out.println(methodName+"开始,参数列表是"+ Arrays.toString(args));
8
        }
9

10
        @After("execution(int *(int,int))")
11
        public void logend(){//后置方法可以获取一下名字,这里就不展示了
12
            System.out.println("结束");
13
        }
14

15
        @AfterReturning(value="execution(int *(int,int))",returning="result")  //写returning指定result接收返回值
16
        public void logreturn(JoinPoint joinPoint,Object result){  //写Object参数来接收返回值
17
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
18
            String name = signature.getName();
19
            System.out.println("返回值是"+result);//把返回值输出
20
        }
21

22
        @AfterThrowing(value="execution(int *(int,int))",throwing = "e") //想加上异常的信息,指定e接收异常的信息
23
        public void logexception(JoinPoint joinPoint,Exception e){//写Exception参数来接收异常信息
24
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
25
            String name = signature.getName();
26
            System.out.println(name+"方法异常了,错误信息是"+e.getMessage());//把异常信息输出
27
        }

1
 @Pointcut("execution(int com.atguigu.maven.spring02.jisuanqi.shuxue.*(..))")
2
    public void asd() {} //方法名写啥都行
3

4
//之后写切入点表达式,
5
 //asd() 就代表execution(int com.atguigu.maven.spring02.jisuanqi.shuxue.*(..))
6
 @Before("asd()")
7
    public void logstart(JoinPoint joinPoint){//这个joinPoint就代表连接点,连接点里有当前方法的全部信息
8
        //Signature signature = joinPoint.getSignature();//拿到方法全签名
9
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();//转换成MethodSignature
10
        String methodName = signature.getName();//拿到方法名
11
        Object[] args = joinPoint.getArgs();//参数值
12
        System.out.println(methodName+"开始,参数列表是"+ Arrays.toString(args));
13
    }

1
@Aspect
2
@Component
3
public class AroundAspect {
4
    @Pointcut("execution(int org.springdata.spring02aop.Calculator.MathCalculator.*(int,int))")
5
    public void pointcut(){}
6
        /*
7
        环绕通知的固定写法如下
8
        public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable{
9
        }
10
         */
11
        @Around("pointcut()")
12
        public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable{
13
            //Object是返回值,因为可能会切各种方法,不确定那些方法具体返回类型
14
            System.out.println("环绕的前置通知");
15
            Object proceed = null;
16
            try {
17
                proceed = pjp.proceed();//继续执行目标方法  这句话类似于动态代理的method.invoke,
18
                System.out.println("环绕的返回通知");
19
            }catch (Throwable e){
20
                System.out.println("环绕的异常通知");
21
                throw e;//让别人继续感知到异常
22
            }
23
            finally {
24
                System.out.println("环绕的后置通知");
25
            }
26
            Object[] args = pjp.getArgs();//获取目标方法的参数
27
            //Object proceed = pjp.proceed(这里也可以传参);   如果想修改参数,只需要写args[0] = xxx; 之后把args传入就可以了
28
            return proceed; //想返回什么就可以返回什么,因此可以修改返回值
29
        }
30
    }

1
spring.datasource.url=jdbc:mysql://localhost:3306/你的数据库名字
2
spring.datasource.username=root
3
spring.datasource.password=你的密码
4
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

1
@EnableTransactionManagement

1
@Transactional