MVC思想、Spring层级代码、AOP

MVC设计思想 

概念：

M ：Model 数据层 数据处理/数据的持久化

V ：View 视图层 前端页面相关的内容 (看到的内容)

C ：Control 控制层 控制数据的流转的过程

MVC思想实现就是层级代码结构 

Spring层级代码结构

层级划分

1.Contorller层：控制层 主要实现与前端页面的交互

2.Service层：业务层 主要实现数据的处理（业务最多）

3.Mapper层：持久层 与数据库连接，交互数据行为

4.POJO： 前端传来数据包装成pojo对象进行处理

规则：

1.属性是私有的，方法是共有的，属性使用包装类

2.写代码要从底层往上写，@autoxxx和@Component配套使用

3.被调用者才有接口和实现类，因为controller是与前端相交互，在后端无人调用，所以不需要接口和实现类

编辑POJO

package com.jt.demo10.pojo;
//pojo的作用：pojo的对象一般实现数据传递的
import java.io.Serializable;
//要求对象序列化
// 作用：1.保证数据按照正常格式输出   2.在多线程条件下，共享数据必须序列化
public class User implements Serializable {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

 为社么pojo中使用包装类？

举个例子，在做金融业务时，如果系统出现异常，返回的为系统默认值，那么在包装类中，会返回null，而基本数据类型，如double中，会返回0.0。那么，对于这其中来说，系统拿到null值会直接报错，阻断程序运行；但是如果是0.0，那么系统会继续运行返回错误值。

 编辑Mapper层（@Repository）

package com.jt.demo11.mapper;

import com.jt.demo11.pojo.User;

public interface UserMapper {
    void addUser(User user);
}

实现接口，用 @repository管理实现接口的对象

package com.jt.demo11.mapper;

import com.jt.demo11.pojo.User;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

//@Component
@Repository
public class UserMapperImpl implements UserMapper {
    @Override
    public void addUser(User user) {
        System.out.println("完成用户入库操作："+user.getName());
    }
}

 编辑Service层（@Service），

   @Autowired
    private UserMapper userMapper;

解释：因为service层要调用mapper层的属性，所以需要创建mapper对象，用@Autowired 注入属性

package com.jt.demo11.service;

import com.jt.demo11.pojo.User;

public interface UserService {
    void addUser(User user);
}

 想调用usermapper的属性，需要先将属性注入，注入是面向接口的（DI）

package com.jt.demo11.service;

import com.jt.demo11.mapper.UserMapper;
import com.jt.demo11.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

    //想调用usermapper的属性，需要先将属性注入，注入是面向接口的（DI）
    @Autowired
    private UserMapper userMapper;

    @Override
    public void addUser(User user) {
        userMapper.addUser(user);
    }
}

 编辑Controller层（@Controller）

package com.jt.demo11.controller;

import com.jt.demo11.pojo.User;
import com.jt.demo11.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    public void addUser(){
        User user=new User();
        user.setId(101);
        user.setName("春");
        user.setAge(2022);
        user.setSex("男");
        userService.addUser(user);
    }

}

 配置类

package com.jt.demo11.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.jt.demo11")
public class SpringConfig {
}

 测试类

package com.jt.demo11;

import com.jt.demo11.config.SpringConfig;
import com.jt.demo11.controller.UserController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestMVC {
    public static void main(String[] args) {
        //创建容器对象，加载配置类
        ApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
        //从容器中调用对象
        UserController userController = context.getBean(UserController.class);
        //调用对象的属性
        userController.addUser();

    }
}

代码加载流程

AOP

概念：

面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术，AOP是OOP的延续，

作用：

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

IOC-DI/AOP之间的区别

IOC-DI是对象之间的解耦合，AOP是方法之间的解耦合

代码开发

创建项目：

 清除多余的文件

动态代理分类

1.JDK动态代理

a.JDK动态代理是JDK源码提供的,无需导入额外的jar包.

b.JDK代理对象要求实现和被代理者相同的接口

c.JDK代理创建速度快,运行时稍慢

代码实现

代码分布

配置类

package com.jt.demo01.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.jt.demo01")
public class SpringConfig {

}

目标类

package com.jt.demo01.service;

public interface UserService {
    void addUser();
}

package com.jt.demo01.service;

import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("新增用户成功");
    }
}

代理机制实现

InvocationHandler()底层代码：
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

所以调用时需要创建一个新的接口实现类，并且实现里面的方法invoke（）

package com.jt.demo1.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JDKProxy {
    //object是lang包中的
    public static  Object getProxy(Object target){
        //获取目标对象的类加载器，      类加载器：将class加载到java运行机制中
        ClassLoader loader=target.getClass().getClassLoader();
        //获取接口数组
        Class<?>[] interfaces = target.getClass().getInterfaces();
        //获取处理器对象，将代理对象扩展的内容写到处理器中
        InvocationHandler h= getInvocationHandler(target);
        //创建代理对象
        return Proxy.newProxyInstance(loader,interfaces,h);
    }
    //InvocationHandler()
    public static InvocationHandler getInvocationHandler(Object target){
        return new InvocationHandler() {
            @Override
            //代理机制调用目标方法
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("事务开始");
                //传入目标对象target
                Object result = method.invoke(target, args);
                System.out.println("事务提交");
                return result;
            }
        };
    }
}

 测试类

package com.jt.demo01;

import com.jt.demo01.config.SpringConfig;
import com.jt.demo01.proxy.JDKProxy;
import com.jt.demo01.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestTx {
    public static void main(String[] args) {
        ApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
        //获取目标对象 实现UserService接口
        UserService target = context.getBean(UserService.class);
        //获取代理对象 实现UserService接口
        UserService proxy = (UserService) JDKProxy.getProxy(target);
        proxy.addUser();

    }
}

2.CGLIB动态代理

a.cglib动态代理需要导入额外的包,才能使用.

b.cglib 要求被代理者有无接口都可以, 但是cglib代理对象是目标对象的子类. (继承)

c.cglib创建代理对象时慢,但是运行期速度快.

注解

@repository：标识mapper层，效果和@component一样

@service：标识Service层，效果和@component一样

@Controller：标识Controller层，效果和@component一样

单词

repository：数据库

component：成分，部件（康po nr 特）

proxy：代理

Invocation：调用

handler：处理

invoke：调用