1.AOP

1.基础内容

AOP是面向切面的的编程，AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。

面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术（增强代码），AOP是靠动态代理实现的，

AOP一共有七个术语

1.连接点：每一个方法就是一个连接点

2.切点：要加强代码的方法就是切点

3.通知：要加强的代码内容

4.目标：代理的目标对象

5.植(织)入：把增强代码应用到目标上，生成目标对象

6.切面：切点加上通知就是切面

7.代理：生成的代理对象

通知分类

分别在不同时机调用不同的通知类型

前置通知：@Before

后置通知：@After

返回后通知：@After-Returning

抛出异常通知：@After-throwing

环绕通知：@Around

2.AOP实现

AOP实现要定义切点和，通知类型

3.静态代理和动态代理

静态代理：

public class EasyA implements Shopping{ public void shopping(){
        System.out.println("EasyA");
    }
}

public class Factory {

    public static Shopping getshopping(){
        EasyA easyA=new EasyA();
        Shopping s=new Proxy(easyA);
        Shopping s1=new Proxy(easyA);
        return s;
    }

    public static void main(String[] args) {
        Shopping shopping=getshopping();
        shopping.shopping();
    }
}
public class Proxy implements Shopping{
    Shopping shop;
    public Proxy(Shopping s){
        this.shop=s;
    }
    public void shopping() {
        System.out.println("---------一支穿云箭");
        shop.shopping();
        System.out.println("---------千军万马来相见");
    }
}
     public interface Shopping {
     void shopping();
}

动态代理：

public class EacyInvokinonHandler implements InvocationHandler {
    private  Object proxyedobj;//被代理对象
    public EacyInvokinonHandler(Object proxyedobj){
        this.proxyedobj=proxyedobj;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result=null;//定义方法的返回对象
        //开始正常执行业务逻辑
        System.out.println("--------执行方法之前添加的业务");
       result= method.invoke(proxyedobj,args);
        System.out.println("-------执行方法之后的处理------");
        return result;
    }
}
public interface EasyInterface {
    void easy();
}
 public class EasyObj implements EasyInterface{

    public void easy() {
        System.out.println("------正常业务逻辑");
    }
}
public class Factory {
    public static Object getProxy(Object object){
        //jdk的代理只能实现接口中的方法
       return    Proxy.newProxyInstance(object.getClass().getClassLoader()//类加载器

                ,object.getClass().getInterfaces(),//实现的接口
                new EacyInvokinonHandler(object));//被代理的对象
    }

    public static void main(String[] args) {
        EasyObj easy=new EasyObj();
        Object object=getProxy(easy);//动态生成的代理类的对象
        if (object instanceof EasyInterface){
            System.out.println("obj是代理对象，是EasyInterface的实例");
            EasyInterface easyInterface=(EasyInterface) object;
            easyInterface.easy();
        }
        Class s=object.getClass();
        System.out.println(s);


        EasyA easyA=new EasyA();
        Object obj=getProxy(easyA);
        Shopping s1=(Shopping)obj;
        s1.shopping();
        System.out.println(obj.getClass());
    }
}

2.SpringMVC

1.注解

@Controller：

这个注解会优先将返回的字符串解析成地址，然后跳转到这个地址，如果不想让它解析成地址可以使用@ResponseBody注解，这样就可以返回要返回的

@RestController

这个注解就是类似于加了@ResponseBody的@Controller

@RequestMapping

前端控制器，来浏览器输入这个括号内的字符串地址就会访问到这个方法

@PathVariable   

从路径上获取参数，在浏览器输入本机/端口号/地址之后?参数=--

@requestparam  

  接收参数的时候使用

@Get/Post/Put/DeleteMapping

请求资源状态转换

2.接收前端参数

1.接受一个参数

在前端浏览器?name=张三就可以传递参数

方法只能接受名字叫name的参数
    @RequestMapping("parama")
    public String getparamA(String name){
        return "Springmvc接收到的参数是："+name;
    }

2.接收多个参数

1.map 接受非常灵活（不太严谨）

@RequestParam可以将请求参数注入到对象上

如果不加这个注解，Map就只会是一个Moudle容器

使用这个之后即使不想接受这个参数也必须接受

@RequestMapping("paramb")
    public Map getparamB(@RequestParam Map param){
        return param;
    }

2.使用封装对象接收参数    程序中只接受所需要的数据（严谨）

只会接受想要的参数，如果注入参数会是默认值

 @RequestMapping("paramc")
    public Staff paramc(Staff staff){

        return staff;
    }

Staff类中有name，id，salary，所以只会接受这些参数




@RequestMapping("paramd/{id}")
    public String paramd(@PathVariable Integer id, HttpServletRequest request){
        String username=request.getParameter("username");//得到一个username的参数
        return "参数是"+id+"-------"+username;
    }

3.请求资源状态转换

REST   请求状态转换
//get  post  put  delete
//get      user/1        获取         user/get
//post     user...       新增         user/add
//delete   user/1        删除         user/del?id=1
//put      user....      编辑         user/edit

4.拦截器

1.当请求的路径与拦截器拦截的路径相匹配时，程序会先执行拦截器类（MyInterceptor）的 preHandle() 方法。若该方法返回值为 true，则继续向下执行 Controller（控制器）中的方法，否则将不再向下执行；

2.控制器方法对请求进行处理；

3.调用拦截器的 postHandle() 方法，此时我们可以对请求域中的模型（Model）数据和视图做出进一步的修改；通过 DispatcherServlet 的 render() 方法对视图进行渲染；

4.调用拦截器的 afterCompletion () 方法，完成资源清理、日志记录等工作。

多个拦截器的执行流程

@Component
public class EasyInterceptor implements HandlerInterceptor {

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("-----preHandle");

        return true;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("-----postHandle");

    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("-----afterCompletion----------处理完毕");

    }
}



@Component
@Configuration
public class INterceptorConfig implements WebMvcConfigurer {
    @Autowired
    EasyInterceptor easyInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(easyInterceptor).addPathPatterns("/methodc");
    }

}

5.SpringMVC运行原理

这个需要背过

6. springmvc异常处理机制

@ExceptionHandler 注解(局部处理)表示在这个类中如果出现了指定的异常就会执行这个方法

@ControllerAdvice全局处理，项目内出现一场都会执行这个方法，全局处理里面可以有局部处理

    @GetMapping("ex")
    public CommonResult ex(){
        int i=12/0;
        return CommonResult.success();
    }
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public CommonResult exh(){
        return CommonResult.success(200,"糟糕，页面走丢了！！！！",null);
    }

 7.作用域对象

HttpServletRequest    HttpServletSession   （servletContext）application

8.请求转发和重定向

请求转发，重定向
//转发：同一个服务器中，不同的服务进行转发，浏览器发送了一个请求，可以转发到项目中受保护的资源（WEB-INF），转发是request对象执行forward方法去转发
//重定向：可以在不同服务之间进行跳转（浏览器发送两次请求）,重定向是通过response对象通知浏览器，重新访问(redirect方法)
//Spring默认是转发形式

请求转发是发送一次请求所以在浏览器上面路径还是现实method

重定向会跳转到baidu地址上

@RequestMapping("methoda")
    public String methoda() {
        System.out.println("methoda");
        return "forward:http://www.baidu.com";
    }


@RequestMapping("methoda")
    public String methoda() {
        System.out.println("methoda");
        return "redirect:http://www.baidu.com";
    }