署理模式和Spring MVC

Spring是一个分层的轻量级的开源Java框架。焦点是IOC(Inverse of Control 控制反转)和AOP(Aspect Oriented Programming 面向切面编程)

---

AOP 面向切面

AOP （Aspect Orient Programming）,直译过来就是 面向切面编程，AOP 是一种编程头脑，是面向对象编程（OOP）的一种增补。AOP是通过动态署理实现的面向切面的编程，实如今不修改源代码的环境下给步伐动态同一添加额外功能的一种技能。
AOP的应用场景：

日志、事件、权限、监测

---

Spring AOP的术语：

名称阐明Joinpoint（毗连点）指那些被拦截到的点，在Spring中，指可以被动态署理拦截目标类的方法。Pointcut（切入点）指要对哪些Joinpoint举行拦截，即被拦截的毗连点。Advice（关照）指拦截到Joinpoint之后要做的变乱，即对切入点加强的内容。Target（目标）指署理的目标对象Weaving（植入/织入）指把加强代码应用到目标上，天生署理对象的过程Proxy（署理）指天生的署理对象Aspect（切面）切入点和关照的联合

---

关照分类有五种：

即关照切入的五种机遇
关照阐明before（前置关照）关照方法在目标方法调用之前实行after（后置关照）关照方法在目标方法返回或非常之后实行after-returning（返回后关照）关照方法会在目标方法返回后实行after-throwing（抛出非常关照）关照方法会在目标方法抛出非常后实行around（围绕关照）关照方法会将目标方法封装起来

---

Spring AOP 织入时期

时期阐明编译期切面在目标类编译时被织入，这种方式必要特殊的编译器，AspectJ的织入编译器就是以这种方式织入切面的类加载期切面的目标类加载到JVM时被织入，这种方式必要特殊的类加载器（ClassLoader）它可以再目标类引入应用之前加强目标类的字节码。运行期切面在应用运行到某个时期被织入，一样寻常环境下，在织入切面时，AOP容器会为目标动态的创建一个署理对象，Spring AOP 采取的就是这种织入方式。

---

Spring AOP 基于AspectJ

AspectJ是一个基于Java语言的AOP框架，Spring2.0以后新增了对AspectJ切点表达式支持
界说切点：通过execution函数来界说切点
        语法:execution(访问修饰符 返回范例 方法名 参数 非常)
1.匹配全部类public方法:execution(public * *(..))第一个*表现返回值 ..表现恣意个恣意范例的参数
2.匹配指定包下全部类全部方法: execution(* cn.xxx.dao.*.*(..)) 第一个想*表现忽略权限和返回值范例
3.匹配指定包下全部类全部方法:execution(* cn.xxx.dao..*(..))包罗子包
4.匹配指定类全部方法: execution(* cn.xxx.service.UserService.*(..))
5.匹配实现特定接口全部类方法 : execution(* cn.xxx.dao.GenericDAO+.*(..))
6.匹配全部save开头的方法: execution(* save*(..))
7.匹配某个指定的方法: execution(* com.yh.dao.StudentService.save(..))
通过利用 @Aspect 注解，我们可以将一个类标记为切面类。
利用 @Pointcut 注解用于界说切点表达式

2. @Aspect
3. @Component
4. public class AOPObj {
5.     //定义切点
6.     @Pointcut("execution(* com.easy.controller.EasyAController.testA(..))")
7.     public void pointCuttesta(){}
8.     @Before(value = "pointCuttesta()")
9.     public void before(){
10.         System.out.println("-----前置通知");
11.     }
12.     @AfterThrowing(value = "pointCuttesta()")
13.     public void afterThrowing(){
14.         System.out.println("-----异常通知");
15.     }
16.     @AfterReturning(value = "pointCuttesta()")
17.     public void afterReturn(){
18.         System.out.println("-----返回通知");
19.     }
20.     @After(value = "pointCuttesta()")
21.     public void after(){
22.         System.out.println("-----前置通知");
23.     }
24. }

复制代码

---

Spring 的署理模式

Spring的署理模式指的是Spring框架中利用署理对象来管理和加强目标对象的运动。
意图：为其他对象提供一种署理以控制对这个对象的访问。
重要办理：在直接访问对象时带来的题目，好比说：要访问的对象在长途的呆板上。在面向对象体系中，有些对象由于某些缘故起因（好比对象创建开销很大，大概某些利用必要安全控制，大概必要历程外的访问），直接访问会给利用者大概体系结构带来很多贫困，我们可以在访问此对象时加上一个对此对象的访问层。
何时利用：想在访问一个类时做一些控制。

---

静态署理

静态署理的实现方式是创建一个实现了与目标对象雷同接口的署理类，该署理类在方法调用前后添加额外的逻辑。署理类将目标对象注入进来，并在署理方法中调用目标对象的对应方法。如许，我们可以在不修改目标对象代码的条件下，通过署理类来对目标对象举行加强和控制。

比方，界说一个Shopping接口：

2. public interface Shopping {
3.     void shopping();
4. }

复制代码

有一个接口实现类EasyA

2. public class EasyA implements Shopping{
3.     @Override
4.     public void shopping(){
5.         System.out.println("去购物");
6.     }
7. }

复制代码

创建一个实现了雷同接口的署理类：传入署理类的目标对象，在方法调用前后增长额外的业务逻辑，并在署理方法中调用目标对象的对应方法

2. public class Proxy implements Shopping{
3.     //静态代理
4.     Shopping s;
5.     //需要传入对象
6.     public Proxy(Shopping s){
7.         this.s=s;
8.     }
9.     //前后增加业务
10.     @Override
11.     public void shopping(){
12.         System.out.println("------一支穿云箭");
13.         s.shopping();
14.         System.out.println("------千军万马来相见");
15.     }
16. }

复制代码

这里通过测试工厂类创建对象并演示：

静态署理的长处是实现简单，易于明白和调试。缺点是：
1.代码冗余：当多个被署理类，多个需加强方法的加强内容一样时，代码重复冗余
2.不易维护：每个被署理类必要专门维护一个署理类，类成倍增长，需加强方法增长时，必要同时维护署理类和被署理类

---

动态署理

动态署理在运行时动态地天生类字节码，加载进JVM，分为两种：
JDK动态署理
JDK动态署理是通过接口实现的署理方式。当目标对象实现了接口时，Spring会利用JDK的java.lang.reflect.Proxy类来创建署理对象，署理对象会实现与目标对象雷同的接口，而且在署理方法中添加自界说的加强逻辑。
演示：界说一个接口：

2. public interface EasyInterface {
3.     void easy();
4. }

复制代码

接口实现类中是根本的正常业务逻辑

2. public class EasyObj implements EasyInterface{
3.     @Override
4.     public void easy(){
5.         System.out.println("-----正常业务逻辑");
6.     }
7. }

复制代码

界说署理处理处罚器，实现 InvocationHandler 接口，在署理方法中添加自界说的加强逻辑。

2. //定义代理处理器
3. public class EasyInvocationHandler implements InvocationHandler {
4.     private  Object proxyedObj;//被代理对象
5.     public EasyInvocationHandler(Object proxyedObj){
6.         this.proxyedObj=proxyedObj;//构造方法
7.     }
8.     @Override
9.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
10.         Object result=null;//定义方法的返回对象
11.         System.out.println("-------执行方法之前执行的业务");
12.         try{
13.             result=method.invoke(proxyedObj,args);//正常执行业务逻辑
14.         }catch (Exception e){
15.             System.out.println("抛出异常");
16.         }finally {
17.             System.out.println("-------执行方法之后要做的处理");
18.         }
19.         return result;
20.     }
21. }

复制代码

声明署理工厂，通过Proxy.newProxyInstance方法创建了一个署理对象。该方法必要三个参数：

• ClassLoader：用于加载署理类的类加载器。
  
• interfaces：目标对象所实现的接口数组，署理类会实现这些接口。
  
• InvocationHandler：署理对象调用方法时的处理处罚器。
  

2. public class Factory {
3.     public static Object getProxy(Object obj){
4.         //JDK代理只能实现接口中的方法
5.         return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
6.                 obj.getClass().getInterfaces(),
7.                 new EasyInvocationHandler(obj)
8.         );
9.     }
10. }

复制代码

测试方法：

2.     public static void main(String[] args) {
3.         EasyObj easy=new EasyObj();
4.         Object obj=getProxy(easy);//动态生成的一个代理类的对象
5.         if(obj instanceof EasyInterface){
6.             System.out.println("obj是代理对象是EasyInterface的实例");
7.             EasyInterface e = (EasyInterface) obj;
8.             e.easy();
9.         }
10.         Class c = obj.getClass();
11.         System.out.println(c);
13.         EasyA easya=new EasyA();
15.         obj=getProxy(easya);
16.         System.out.println(obj instanceof Shopping);
17.         Shopping s=(Shopping) obj;
18.         s.shopping();
19.         System.out.println(easy.getClass());
20.     }

复制代码

动态署理的长处是更加机动，可以应用于多个目标对象，但实现和明白相对复杂一些。

---

CGLIB署理
CGLIB署理是通过继续实现的署理方式。当目标对象没有实现任何接口时，Spring会利用CGLIB库来创建署理对象，署理对象将继续目标对象的类，并覆盖此中的方法来添加自界说的加强逻辑。（目标对象的类不可以用final修饰）
被界说切点的类之后利用@Autoward注入时会注入此类的署理类(此类的子类，包罗署理处理处罚器,处理处罚步伐等等)，而不是本类，通过动态署理实现。
前面在EasyAController的testA上界说了切点：
 @Pointcut("execution(* com.easy.controller.EasyAController.testA(..))"
这里我们通过测试打印类对象发现：注入的是此类通过CGLIB动态署理自动天生的署理类：

---

Spring MVC

项目有三层架构：控制层、业务层、数据访问层
与项目标三层架构差别，Spring MVC的三层架构基于MVC计划模式。它将应用步伐的差别部门分为三个独立的层：模子层（Model）、视图层（View）和控制层（Controller）。

---

@Controller 注解

在Spring MVC中，@Controller是一个用于标记控制器类的注解。利用@Controller注解的类被Spring容器辨认为控制器，可以处理处罚来自用户的哀求。
@RequestMapping 注解

@RequestMapping是一个用于映射哀求路径的注解。它可以用在类级别和方法级别上，用于标识控制器类或方法应该处理处罚的哀求路径。
修饰方法：
 @RequestMapping 注解被标注在方法上时，value 属性值就表现访问该方法的 URL 地点。当用户发送过来的哀求想要访问该 Controller 下的控制器方法时，哀求路径就必须与这个 value 值雷同
修饰类：
 @RequestMapping 注解标注在控制器类上时，value 属性的取值就是这个控制器类中的全部控制器方法 URL 地点的父路径。也就是说，访问这个 Controller 下的恣意控制器方法都必要带上这个父路径。

2. @RestController
3. @RequestMapping("user")
4. public class EasyDController {
5.     // ...
6. }

复制代码

---

@RequestMapping注解可以传入多种属性：
1. value 属性

• 在 @RequestMapping 注解中，value 属性用来设置控制器方法的哀求映射地点。全部可以大概匹配到该哀求映射地点的哀求，都可以被该控制器方法处理处罚
  
• value 属性是 @RequestMapping 注解的默认属性，假如我们在 @RequestMapping 注解中只设置了一个 value 属性，则该属性名可以被省略
  
• value 属性的取值是一个字符串范例的数组，表现该控制器方法可以匹配多个哀求地点。
  

2. name 属性

• name 属性相当于方法的解释，用于表明这个方法是用来干什么的，使方法更易明白。
  

如：@RequestMapping(value = "toUser",name = "获取用户信息")
3. method 属性

• method 属性用来设置控制器方法支持的哀求方式。假如一个控制器方法没有设置 @RequestMapping 注解的 method 属性，则阐明该控制器方法支持全部哀求范例，可以处理处罚全部范例的哀求。
  
• method 属性的取值是一个 RequestMethod 范例的数组，表现一个控制器方法支持多种方式的哀求，常用的哀求方式有 GET、POST、DELETE、PUT 等。
  

哀求资源状态转换哀求方式作用GET（获取资源）用于从服务器获取数据，可以在URL中转达参数，参数会袒露在URL上，通常用于获取数据。POST（提交数据）用于向服务器提交数据，数据不会袒露在URL上，通常用于提交表单数据、上传文件等。DELETE（删除资源）用于删除服务器上的资源，通常用于删除指定的数据。PUT（更新资源）用于更新服务器上的资源，通常用于更新指定的数据。如：@RequestMapping(value = "/toUser",method = RequestMethod.GET)

• 我们也可以为同一个控制器方法指定支持多种范例的哀求。比方，一个方法既支持 GET 方式的哀求，也支持 POST 方式的哀求
  

如：@RequestMapping(value = "/toUser",method = {RequestMethod.GET,RequestMethod.POST})
4. params 属性

• params 属性用于指定哀求中的参数，只有当哀求中携带了符合条件的参数时，控制器方法才会对该哀求举行处理处罚。
  

• params 属性的取值是一个字符串范例的数组，表现只有哀求中同时携带了 params 属性指定的全部参数时，控制器方法才会对该哀求举行处理处罚。
  

如：@RequestMapping(value = "/testParam", params = {"name=javaeasy", "url=www.easy.com"})
5. headers 属性

• headers 属性用于设置哀求中哀求头信息，只有当哀求中携带指定的哀求头信息时，控制器方法才会处理处罚该哀求。
  

• header 属性是一个字符换范例的数组，表现只有当哀求同时携带数组中规定的全部头信息时，控制器方法才会对该哀求举行处理处罚。
  

如：@RequestMapping(value = "toUser",headers = "Referer=http://c.biancheng.net")

---

映射地点支持 Ant 风格的路径

Spring MVC 还提供了对 Ant 风格路径的支持，我们可以在 @RequestMapping 注解的 value 属性中利用 Ant 风格的统配符，来设置哀求映射地点。

---

Spring MVC 获取哀求参数

1.通过形参获取哀求参数
在 Controller 的控制器方法中设置与哀求参数同名的形参，以获取哀求中携带的参数。当欣赏器发送的哀求匹配到这个控制器方法时，Spring MVC 会自动将哀求参数赋值给相应的方法形参。
注意：
（1）必须包管参数名划一

• 我们必须包管控制器方法的形参名称与哀求中携带参数的名称完全划一（区分巨细写），否则控制器方法吸取到的哀求参数值会是 null。
  
• 假如由于一些特殊缘故起因，着实无法包管参数名严格划一，可以通过 @RequestParam 注解来办理。
  

（2）无视数据范例

• 在控制器方法中利用 String 字符串范例的形参吸取全部的哀求参数，也可以根据现实环境在控制器方法中利用对应数据范例的参数来吸取哀求参数，而无须自行举行数据范例转换。
  

（3）不实用于哀求参数过多的哀求
同名哀求参数的处理处罚方式：

2.     //接收前端的参数   方法的参数名称和前台传递的参数名一样
3.     @RequestMapping("parama")
4.     public String paramA(String name){
5.         return "spingmvc接收到的参数:"+name;
6.     }

复制代码

2.     //获取地址上的参数
3.     @RequestMapping("paramd/{id}")
4.     public String paramD(@PathVariable Integer id, HttpServletRequest request){
5.         String username= request.getParameter("username");
6.         return "接收到的参数是:"+id+"----nsername:"+username;
7.     }

复制代码

@PathVariable是Spring MVC中用于将URL路径中的变量提取到方法参数中的注解。它可以用于在控制器方法中获取URI路径中的值，并将其绑定到方法的参数上。

---

利用@RequestParam
可以在控制器方法中通过 @RequestParam 注解，在哀求参数与控制器方法的形参之间创建起映射关系，将它们绑定起来。如许纵然哀求参数与控制器方法中的形参名称不划一，也能获取到对应的哀求参数值。

2.     //同时接收多个参数 Map 接收，非常灵活，但是有安全问题
3.     @RequestMapping("paramb")
4.     public Map paramB(@RequestParam Map params){//默认是model的容器，加了注解就作为存储参数的容器
5.         // 将请求的参数注入到对象中
6.         return params;
7.     }

复制代码

利用Map可以非常机动的吸取多个参数，但会将传入的参数通盘吸取，受到恶意攻击有安全题目

---

2.通过实体类对象获取（保举）
在 Controller 控制器方法的形参中设置一个实体类形参，假如哀求参数的参数名与实体类中的属性名划一，那么 Spring MVC 会自动将哀求参数封装到该实体类对象中。此时我们就可以通过该实体类对象获取所需的哀求参数了。

2.     //使用封装对象接收 程序中只接收我们需要的数据
3.     @RequestMapping("paramc")
4.     public Staff paramc(Staff staff){
5.         return staff;
6.     }

复制代码

这种方式当传入多个参数时，只会生存匹配到所需的参数，可以大概有用地办理“控制器方法形参不实用于哀求参数过多的哀求”题目。

---

哀求转发和重定向

哀求转发（Forward）是指将当前的HTTP哀求转发给另一个资源举行处理处罚，然后将处理处罚效果再返回给客户端。哀求转发是在服务器内部完成的，客户端对此过程是无感知的。在哀求转发时，URL地点栏不会改变。
转发：同一个服务器中差别的服务举行转发，可以转发到项目中受掩护的资源 如 WEB-INF，是request对象实行forward方法。
当控制器方法中所设置的逻辑视图名称以“forward:”为前缀时，该逻辑视图名称不会被 Spring MVC 设置的视图剖析器剖析，而是会将前缀“forward:”去掉，以剩余部门作为终极路径通过转发的方式实现跳转。

---

哀求重定向（Redirect）是指服务器收到客户端的哀求后，返回一个特殊的相应码和一个新的URL地点给客户端，让客户端重新发送一个新的哀求到这个URL地点。客户端会根据新的URL地点再次发起哀求，并在URL地点栏表现新的地点。重定向是在客户端完成的。
重定向：欣赏器发送了两次哀求，可以访问到本项目之外的外网资源，重定向在Java Servlet中是通过response对象关照欣赏器重新访问，利用redirect来重定向。

2.     @RequestMapping("methoda")
3.     public String methodA(){
4.         System.out.println("-----methodA");
5.         return "redirect:/methodb";
6.     }
7.     @RequestMapping("methodb")
8.     @ResponseBody
9.     //将返回值直接写入回应对象
10.     public String methodB(){
11.         System.out.println("-----methodB");
12.         return "this is methodB";
13.     }

复制代码

哀求转发和重定向都可以用于页面跳转和流程控制，但它们之间有一些区别：

• 哀求转发是服务器内部的利用，速率较快，而重定向是必要客户端重新发起哀求，速率较慢。
  
• 哀求转发是在服务器内部举行的，因此共享了同一个HTTP哀求对象；而重定向是两次独立的哀求，每次哀求都是独立的，因此无法共享数据。
  
• 哀求转发可以在同一个哀求中访问被转发的资源，而重定向则会创建一个新的哀求，无法直接访问之前的资源。
  

---

Spring MVC 拦截器

拦截器（Interceptor）是 Spring MVC 提供的一种强大的功能组件。它可以对用户哀求举行拦截，并在哀求进入控制器（Controller）之前handler、控制器处理处罚完哀求后、乃至是渲染视图后，实行一些指定的利用。
在 Spring MVC 中，拦截器的作用与 Servlet 中的过滤器雷同，它重要用于拦截用户哀求并做相应的处理处罚，比方通过拦截器，我们可以实行权限验证、纪录哀求信息日志、判定用户是否已登录等利用。
界说拦截器
Spring MVC 在 org.springframework.web.servlet 包中提供了一个 HandlerInterceptor 接口

2. @Component
3. public class EasyInterceptor implements HandlerInterceptor {
4.     //三个方法，前置，后置，处理完毕
5.     @Override
6.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
7.         System.out.println("-----preHandle");
8.         return true;
9.         //return HandlerInterceptor.super.preHandle(request, response, handler);
10.     }
11.     @Override
12.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
13.         System.out.println("-----postHandle");
14.         //HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
15.     }
16.     @Override
17.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
18.         System.out.println("-----afterCompletion--整个请求处理完毕");
19.         //HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
20.     }
21. }

复制代码

在三种方法中实现业务逻辑，上述代码仅作为演示过程利用。
设置拦截器

2. @Configuration
3. public class InterceptorConfig implements WebMvcConfigurer{
4.     //拦截器的注册中心
5.     @Autowired
6.     EasyInterceptor easyInterceptor;
7.     @Override
8.     public void addInterceptors(InterceptorRegistry registry) {
9.         registry.addInterceptor(easyInterceptor)
10.                 //要拦截的地址
11.                 .addPathPatterns("/methodc")
12.                 //排除在外的地址
13.                 .excludePathPatterns("/","/index");
14.     }
15. }

复制代码

---

Spring MVC 的工作流程

• 用户通过欣赏器发起一个 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（视图剖析器）

---

Spring MVC 非常处理处罚

在现实的应用开辟中，经常会不可克制地碰到各种可预知的、不可预知的非常，此时我们就必要对这些非常处理处罚，以包管步伐正常运行。
Spring MVC 提供了一个名为 HandlerExceptionResolver 的非常处理处罚器接口，它可以对控制器方法实行过程中出现的各种非常举行处理处罚。
Srping MVC 为 HandlerExceptionResolver 接口提供了多个差别的实现类：
DefaultHandlerExceptionResolver
ResponseStatusExceptionResolver
ExceptionHandlerExceptionResolver
SimpleMappingExceptionResolver

• ExceptionHandlerExceptionResolver、ResponseStatusExceptionResolver 和 DefaultHandlerExceptionResolver 是 Spring MVC 的默认非常处理处罚器。
  
• 假如步伐发生非常，Spring MVC 会按照 ExceptionHandlerExceptionResolver → ResponseStatusExceptionResolver → DefaultHandlerExceptionResolver 的序次，依次利用这三个非常处理处罚器对非常举行剖析，直到完成对非常的剖析工作为止。
  

这里编写一个哀求效果类，用于在欣赏器发出哀求后反馈自界说的对应效果：

2. public class CommonResult {
3.     private int code;
4.     private String message;
5.     private Object data;
6.     public CommonResult(int code, String message, Object data) {
7.         this.code = code;
8.         this.message = message;
9.         this.data = data;
10.     }
11.     public static CommonResult success(int code, String message, Object data){
12.         return new CommonResult(code, message, data);
13.     }
14.     public static CommonResult success(){
15.         return new CommonResult(200, "操作成功", null);
16.     }
17.     public static CommonResult fail(int code, String message, Object data){
18.         return new CommonResult(code, message, data);
19.     }
20.     public static CommonResult fail(){
21.         return new CommonResult(400,"操作失败",null);
22.     }
23.     //其他不同参数的方法重载...
24.     //getter和setter方法...
25. }

复制代码

界说非常处理处罚器：
局部处理处罚

• Spring MVC 答应我们在控制器类（Controller 类）中通过 @ExceptionHandler 注解来界说一个处理处罚非常的方法，以实现对控制器类内发生非常的处理处罚。
  
• @ExceptionHandler 注解中包罗了一个 value 属性，我们可以通过该属性来声明一个指定的非常。假如在步伐运行过程中，这个 Controller 类中的方法发生了这个指定的非常，那么 ExceptionHandlerExceptionResolver 就会调用这个 @ExceptionHandler 方法对非常举行处理处罚。
  
• 界说在某个控制器类中的 @ExceptionHandler 方法只在当前的控制器中有用，它只能处理处罚其地点控制器类中发生的非常。
  
• @ExceptionHandler 方法的优先级--指定非常范例最正确的
  

2.     @ExceptionHandler(Exception.class)
3.     @ResponseBody
4.     public CommonResult exh(){
5.         return CommonResult.success(200,"稍有问题");
6.     }

复制代码

利用 @ResponseBody 注解时，可以在控制器方法上添加该注解，将方法的返回值直接转换为指定格式（如JSON、XML等）的相应，并发送给客户端。
全局处理处罚

• @ExceptionHandler 方法界说在一个利用了 @ControllerAdvice 注解的类中。利用 @ControllerAdvice 注解的类可以包罗多个差别的带有 @ExceptionHandler 注解的方法
  

2. @RestController
3. @ControllerAdvice
4. //这样下面的异常处理器就不止处理本类的异常，可以处理整个项目的异常
5. public class StaffController {
6.     //...
7. }

复制代码

---

API接口测试

Apipost是一个用于测试和调试API接口的工具。它可以资助开辟职员在开辟和调试API接口时，方便地发送HTTP哀求，并检察哀求和相应的内容和效果。
编写如下控制类用于测试，启动项目：

2. @RestController
3. public class StaffController {
4.     @GetMapping("staff")
5.     public CommonResult getList(Staff staff){
6.         List<Staff> list=null;
7.         System.out.println("获取数据");
8.         return CommonResult.success(list);
9.     }
10.     @PostMapping("staff")
11.     public CommonResult addStaff(Staff staff){
12.         System.out.println("新增数据");
13.         return CommonResult.success();
14.     }
15.     @DeleteMapping("staff/{id}")
16.     public CommonResult deleteStaff(@PathVariable int id){
17.         System.out.println("删除数据"+id);
18.         return CommonResult.success();
19.     }
20.     @PutMapping("staff")
21.     public CommonResult editStaff(Staff staff){
22.         System.out.println("编辑数据");
23.         return CommonResult.success();
24.     }
25. }

复制代码

打开Apipost，新建接口：

输入端标语，地点并选择哀求方式，发送哀求：