Spring(Day 17)

一、Spring两大核心

1**.IOC**与 DI

• 思想：IoC（Inverse of Control：控制反转）是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。
• IoC 容器是 Spring 用来实现 IoC 的载体， IoC 容器实际上就是个Map（key，value）,Map 中存放的是各种对象。
• 将对象之间的相互依赖关系交给 IoC 容器来管理，并由 IoC 容器完成对象的注入。这样可以很大程度上简化应用的开发，把应用从复杂的依赖关系中解放出来。
• IoC 容器就像是一个工厂一样，当我们需要创建一个对象的时候，只需要配置好配置文件xml/注解即可，完全不用考虑对象是如何被创建出来的。
• IoC 是一个概念，是一种思想，其实现方式多种多样。Spring 框架使用依赖注入（DI）实现 IoC
• 定义： DI---Dependency Injection ，即 " 依赖注入 "。依赖注入 DI 是指程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。
• 通常，依赖注入可以通过三种方式完成，即：构造函数注入，setter 注入，接口注入。在 Spring Framework 中，仅使用构造函数和 setter 注入 。
• Spring IOC 作用：管理项目中的Java bean的生命周期
• 为什么需要：在项目运行阶段，程序中需要很多对象来完成整体业务
• 容器和代码之间的代码控制权反转，代码中不需要明文调用来方法得到对象， 只需要声明该类需要什么类型的对象即可

2.AOP

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

• AOP的作用

  • AOP 采取横向抽取机制（动态代理），取代了传统纵向继承机制的重复性代码，其应用主要体现在事务处理、日志管理、权限控制、异常处理等方面。

  • 主要作用是分离功能性需求和非功能性需求，使开发人员可以集中处理某一个关注点或者横切逻辑，减少对业务代码的侵入(拦截器---切入点)，增强代码的可读性和可维护性。

  • 简单的说，AOP 的作用就是保证开发者在不修改源代码的前提下，为系统中的业务组件添加某种通用功能。

• Spring AOP的术语

• Spring AOP 通知分类

• 定义切点

  • 通过execution函数来定义切点

  • 语法:execution(访问修饰符 返回类型 方法名 参数 异常)

具体事例说明：(..):表示方法参数列表，其中..表示任意数量和类型的参数。

• 匹配所有类public方法:execution(public * *(..))第一个*表示返回值 ..表示任意个任意类型的参数
• 匹配指定包下所有类所有方法: execution(* cn.xxx.dao.*.*(..)) 第一个想*表示忽略权限和返回值类型
• 匹配指定包下所有类所有方法:execution(* cn.xxx.dao..*(..))包含子包
• 匹配指定类所有方法: execution(* cn.xxx.service.UserService.*(..))
• 匹配实现特定接口所有类方法 : execution(* cn.xxx.dao.GenericDAO+.*(..))
• 匹配所有save开头的方法: execution(* save*(..))
• 匹配某个指定的方法: execution(* com.yh.dao.StudentService.save(..))

二、代理模式

1.静态代理

2.动态模式

2.1 JDK动态代理（组合，被代理类必须实现接口）

• 代码实现

  • 定义接口

• 定义代理处理器

//正常执行业务逻辑

//作用是调用被代理对象的实际方法，但并不是调用被代理对象的所有方法。它只会调用当前被拦截的方法。

• result = method.invoke(proxyedObj, args);

• 声明代理工厂

• 方法测试

2.2 CGLIB动态代理（继承，被代理类不能被final修饰）

• 定义业务类

• 定义代理业务

• 代码测试

三、 拦截器

1.拦截器（Interceptor）是 Spring MVC 提供的一种强大的功能组件。它可以对用户请求进行拦截，并在请求进入控制器（Controller）之前handler、控制器处理完请求后、甚至是渲染视图后，执行一些指定的操作。

//正常执行业务逻辑

//作用是调用被代理对象的实际方法，但并不是调用被代理对象的所有方法。它只会调用当前被拦截的方法。

• result = method.invoke(proxyedObj, args);

2.在 Spring MVC 中，拦截器的作用与 Servlet 中的过滤器类似，它主要用于拦截用户请求并做相应的处理，例如通过拦截器，我们可以执行权限验证、记录请求信息日志、判断用户是否已登录等操作。

• 1.拦截器定义与逻辑代码
• preHandle() 返回值判断是否会进行后续操作，true会继续（不拦截），false不会继续（进行拦截）

@Component
public class Interceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("-----preHandle：返回值判断是否会进行后续操作");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

        System.out.println("--------postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("--------afterCompletion");
    }
}

• 2. 配置拦截器

• 拦截器的执行流程

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

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

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

  • 通过 DispatcherServlet 的 render() 方法对视图进行渲染；

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

• 多个拦截器的执行流程。

  • 在大型的企业级项目中，通常都不会只有一个拦截器，开发人员可能会定义许多不同的拦截器来实现不同的功能。

  • 

四、springmvc 运行原理

Spring MVC 使用 MVC 架构模式的思想，将 Web 应用进行职责解构，把一个复杂的 Web 应用划分成模型（Model）、控制器（Contorller）以及视图（View）三层，有效地简化了 Web 应用的开发，降低了出错风险，同时也方便了开发人员之间的分工配合

• 用户通过浏览器发起一个 HTTP 请求,该请求会被 DispatcherServlet(前端控制器)拦截；

• DispatcherServlet 调用 HandlerMapping（处理器映射器）找到具体的处理器（Handler）及拦截器，

• HandlerMapping将Handler以 HandlerExecutionChain 执行链的形式返回给 DispatcherServlet。

• DispatcherServlet 将执行链返回的 Handler 信息发送给 HandlerAdapter（处理器适配器）；

• HandlerAdapter 根据 Handler 信息找到并执行相应的 Handler（即 Controller 控制器）对请求进行处理；

• Handler 执行完毕后会返回给 HandlerAdapter 一个 ModelAndView 对象（Spring MVC 的底层对象，包括 Model 数据模型和 View 视图信息）；

• HandlerAdapter 接收到 ModelAndView 对象后，将其返回给 DispatcherServlet ；

• DispatcherServlet 接收到 ModelAndView 对象后，会请求 ViewResolver（视图解析器）对视图进行解析；

• ViewResolver 解析完成后，会将 View 视图并返回给 DispatcherServlet；

• DispatcherServlet 接收到具体的 View 视图后，进行视图渲染，将 Model 中的模型数据填充到 View 视图中的 request 域，生成最终的 View（视图）；

• 视图负责将结果显示到浏览器（客户端）。

• Spring MVC 常用(核心)组件

  • Spring MVC 的常用组件共有 5 个，它们分别是： DispatcherServlet（前端控制器）、HandlerMapping（处理器映射器）、HandlerAdapter（处理器适配器）、Handler（处理器）、ViewResolver（视图解析器）

  • 

五、springmvc异常处理机制

• 如果程序发生异常，Spring MVC 会按照 ExceptionHandlerExceptionResolver → ResponseStatusExceptionResolver → DefaultHandlerExceptionResolver 的顺序，依次使用这三个异常处理器对异常进行解析，直到完成对异常的解析工作为止。

• @ExceptionHandler 注解(局部处理）

• 

• 全局异常处理

  • @ExceptionHandler 方法定义在一个使用了 @ControllerAdvice 注解的类中。使用 @ControllerAdvice 注解的类可以包含多个不同的带有 @ExceptionHandler 注解的方法

六、相关注解

1、@Controller 与 @RestController 区别：

@Controller：返回值优先作为地址，如果要返回json，需要添加@ResponseBody

• @Controller是Spring MVC中用于定义传统Web控制器的注解。它通常与视图技术（如JSP、Thymeleaf）一起使用，返回一个视图名称，由视图解析器解析并渲染视图。

特点：

• 返回视图名称：@Controller 通常返回一个地址（如"home"），由视图解析器解析为具体的视图实现（如JSP、Thymeleaf模板）。
• 使用@RequestMapping：方法上通常使用@RequestMapping注解来映射请求。
• 使用@ResponseBody：如果需要返回JSON、XML等数据，可以在方法上添加@ResponseBody注解，将返回值直接写入HTTP响应体。

@RestController：返回值类型json

@RestController 是Spring 4.0引入的一个组合注解，它结合了@Controller和@ResponseBody的功能。主要用于构建RESTful Web服务，返回JSON、XML等数据，而不是视图。

特点

1. 直接返回数据 ：@RestController 的方法默认返回数据，而不是视图名称。返回值会自动转换为JSON或XML格式，并写入HTTP响应体。
2. 简化注解 ：不需要在每个方法上添加@ResponseBody注解，简化了代码。
3. 适用于RESTful服务 ：非常适合构建RESTful Web服务，返回纯数据。

2. JSON 数据转换

• Spring MVC 为我们提供了两个十分重要的与 JSON 格式转换相关的注解，它们分别是 @RequestBody 和 @ResponseBody。

• 

3. Spring MVC实现RESTful

• 在 Spring MVC 中，我们可以通过 @RequestMapping +@PathVariable 注解的方式，来实现 RESTful 风格的请求。

• 通过@RequestMapping 注解的路径设置

  • 当请求中携带的参数是通过请求路径传递到服务器中时，我们就可以在 @RequestMapping 注解的 value 属性中通过占位符 {xxx} 来表示传递的参数

  • @RequestMapping("/testRest/{id}/{username}")

  • value(路径) 属性中占位符的位置应当与请求 URL 中参数的位置保持一致，否则会出现传错参数的情况。

• 通过 @PathVariable 注解绑定参数

  • 我们可以在控制器方法的形参位置通过 @PathVariable 注解，将占位符 {xxx} 所表示的参数赋值给指定的形参。

@RestController
//处理全局的异常
@RequestMapping("staff")
public class StaffController {

   @GetMapping("staff")
   public CommonResult getList(Staff staff){
      List<Staff> list =null;

      System.out.println("获取数据");
       return CommonResult.success(list);
   }

   @PostMapping("staff")
   public CommonResult addStaff(Staff staff){
      System.out.println("新增数据");
      return CommonResult.success();
   }
    @PutMapping("staff")
   public CommonResult update(){
      System.out.println("编辑数据");
       return CommonResult.success();


   }
   @DeleteMapping("staff/{id}")
   public CommonResult  delStaff(@PathVariable int id){
      System.out.println("删除数据"+id);
      return CommonResult.success();
   }

   @GetMapping("ex")
   public CommonResult ex(){
      System.out.println("+++++++++++++++++");
      int a=12/0;
      return CommonResult.success();
   }

   @ExceptionHandler(Exception.class)
   @ResponseBody
   public CommonResult exh(){
      System.out.println("----------------");
      return CommonResult.success(200,"稍有问题");
   }
}

七、接收前端的参数

接收前端的参数  方法的参数名称和前台传递的参数名一样
（一）、获取表单数据
 1. Map接收（非常灵活，但不严谨，有安全问题）
 2.使用封装对象来接收参数  程序当中只接收我们所需要的数据
（二）、获取地址栏上的参数

1. 查询参数 ： 从URL的查询参数中获取值，使用 @RequestParam 注解。

   @GetMapping("/users")
   public User getUserById(@RequestParam Long id) {
       // 从查询参数中获取id
       return userService.getUserById(id);
   }
   

   请求示例：GET /users?id=123

2. 请求体 ： 从HTTP请求体中获取值，使用 @RequestBody 注解。

   @PostMapping("/users")
   public User createUser(@RequestBody User user) {
       // 从请求体中获取User对象
       return userService.createUser(user);
   }
   

   请求示例：POST /users，请求体中包含User对象的JSON数据。

3.加 @PathVariable 注解

如果加 @PathVariable 注解，方法参数将从URL路径中获取值。

@GetMapping("/users/{id}")
public User getUserById(@PathVariable Long id) {
    // 从URL路径中获取id
    return userService.getUserById(id);
}

请求示例：GET /users/123

   //@Controller  将返回值优先当做地址
    //@RestController
      //REST 请求资源状态转换
   //get post put deldte
    //get user/1     获取   user/get
    //get user/......(参数)    新增   user/add
    //delete user/1     删除     user/del?id=1
    //put user......       编辑     user/edit
@RestController
@RequestMapping("user")

public class EasyDController {
    //接收前端的参数  方法的参数名称和前台传递的参数名一样
    //一、获取表单数据

    @RequestMapping("parama")
    public String praamA(String name){
        return "Stringmvc接收到的参数是："+name;
    }

    //同时接收多个参数：2种方式
    // 1. Map接收（非常灵活，但不严谨，有安全问题）
    @RequestMapping("paramb")
               //加注解：变成接收参数的容器，将参数注入到map里面，如果没有就认为是创建一个对象
    public Map praamb(@RequestParam  Map params){
        return params;
    }


    //2.使用封装对象来接收参数  程序当中只接收我们所需要的数据
    @RequestMapping("paramc")
    public Staff  paramc(Staff staff){

        return staff;
    }


    //二、获取地址栏上的参数
        @RequestMapping("paramd/{id}")
                        //获取地址栏上的参数
        public String paramd(@PathVariable  Integer id, HttpServletRequest request){
            String username = request.getParameter("username");

            return "接收到的参数是："+id+"---username:"+username;
        }


        /*作用域对象：
        page
        HttpServletRequest
        HttpSeesion(ServletContext)
        application
        */

    @RequestMapping("easyaa")
     public String easyaa(){
         return "easyaa method";
     }





}

八、请求转发与重定向区别

 /*请求转发：同一个服务器中不同的服务进行转发，
               浏览器发送一个请求，可以转发到到本项目中受保护的资源（例如：WEB-INF）
               (地址栏不发生变化)     forward
               转发是request对象执行forward方法进行转发
               （默认是转发）

     * 重定向： 可以在不同的服务器之间跳转，
              浏览器发送多次请求对象
              （地址栏发生变化）      redirect
              重定向是通过response对象通知浏览器重新访问，使用redirect来重定向*/

@Controller
public class EasyEController {
    @RequestMapping("methoda")
    public String methodA(){
        System.out.println("------methodA");
        //return "forward:/methodb";
        return "redirect:/methodb";
    }

    @RequestMapping("methodb")
     //将返回对象直接返回到响应体里面
    @ResponseBody
    public String methodB(){
        System.out.println("------methodB");
        return "this is methodB";
    }

    @RequestMapping("methodc")
    public String methodC(){
        return "index.jsp";
    }
}