SpringBoot开发常见知识积累

SpringBoot获取Request和Response

通过静态方法获取，你也可以封装一个静态方法出来

public String test() {
	ServletRequestAttributes attributes = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
	HttpServletRequest request = attributes.getRequest();
	HttpServletResponse response = attributes.getResponse();


}

实例，日志切面获取请求信息:

通过参数直接获取
只要在你的方法上加上参数，Springboot就会帮你绑定，你可以直接使用。如果你的方法有其他参数，把这两个加到后面即可。

在Controller方法里

@RequstMapping(value = "")
public String test(HttpServletRequest request,HttpServletResponse response) {
 
 
}

注入到类
，这样就不用每个方法都写了

@Autowired
private HttpServletRequest request;
@Autowired
private HttpServletResponse response;
 
@GetMapping(value = "")
public String test() {
 
}

事务使用@Transactional

AOP开发流程

AOP（Aspect Oriented Programing）：面向切面编程，将通用的逻辑从业务逻辑中分离出来。AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理。Aop 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说，AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离”。

相关概念：
连接点（Joinpoint）: 表示需要在程序中插入横切关注点的扩展点，连接点可能是类初始化、方法执行、方法调用、字段调用或处理异常等等，Spring只支持方法执行连接点；在AOP中表示为“在哪里干”；

切入点（Pointcut）: 选择一组相关连接点的模式，即可以认为连接点的集合，Spring支持perl5正则表达式和AspectJ切入点模式，Spring默认使用AspectJ语法；在AOP中表示为“在哪里干的集合”；

通知（Advice）: 在连接点上执行的行为，通知提供了在AOP中需要在切入点所选择的连接点处进行扩展现有行为的手段；包括前置通知（before advice）、后置通知(after advice)、环绕通知（around advice），在Spring中通过代理模式实现AOP，并通过拦截器模式以环绕连接点的拦截器链织入通知；在AOP中表示为“干什么”；

切面（Aspect）：横切关注点的模块化，比如日志组件。可以认为是通知、引入和切入点的组合；在Spring中可以使用Schema和@AspectJ方式进行组织实现；在AOP中表示为“在哪干和干什么集合”；
引入（Introduction）: 也称为内部类型声明，为已有的类添加额外新的字段或方法，Spring允许引入新的接口（必须对应一个实现）到所有被代理对象（目标对象）；在AOP中表示为“干什么（引入什么）”；
目标对象（Target Object）:需要被织入横切关注点的对象，即该对象是切入点选择的对象，需要被通知的对象，从而也可称为“被通知对象”；由于Spring AOP 通过代理模式实现，从而这个对象永远是被代理对象；在AOP中表示为“对谁干”；
AOP代理（AOP Proxy）: AOP框架使用代理模式创建的对象，从而实现在连接点处插入通知（即应用切面），就是通过代理来对目标对象应用切面。在Spring中，AOP代理可以用JDK动态代理或CGLIB代理实现，而通过拦截器模型应用切面。
织入（Weaving）: 织入是一个过程，是将切面应用到目标对象从而创建出AOP代理对象的过程，织入可以在编译期、类装载期、运行期进行。组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

Aop常见的概念：

概念	说明
切点	要添加代码的地方，称作切点
通知（增强）	通知就是向切点动态添加的代码
切面	切点+通知
连接点	切点的定义

开发步骤：
引入

 <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.2</version>
        </dependency>

第一步 定义一个切面类@Aspect
第二步 定义一个切点方法@PointCut ，@Poincut注解表示切入的点，即程序中通用的逻辑业务，这里是请求的路径
第三步 基于该切点 业务处理前做如何操作@Before 业务处理之后做如何操作@After
日志开发示例：

package com.example.aspect;
 
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.JoinPoint;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
 
import javax.servlet.http.HttpServletRequest;
 
@Aspect
@Component
public class HttpAspect {
 
    private final static Logger logger = LoggerFactory.getLogger(HttpAspect.class);
 
    //@Before的注解在方法执行之前执行
    //拦截该路径下studentList()方法，两个点表示任何参数
//    @Before("execution(public * com.example.controller.StudentController.studentList(..))")
//    public void log(){
//        System.out.println("Test before");
//    }
//
//    @After("execution(public * com.example.controller.StudentController.studentList(..))")
//    public void doAfter(){
//        System.out.println("Test after");
//    }
 
    //定义一个公用方法
    @Pointcut("execution(public * com.example.controller.StudentController.*(..))")
    public void log(){
    }
 
    @Before("log()")
    public void doBefore(JoinPoint joinPoint){
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
 
        //url
        logger.info("url={}", request.getRequestURI());
 
        //method
        logger.info("method={}", request.getMethod());
 
        //ip
        logger.info("ip={}", request.getRemoteAddr());
 
        //method
        logger.info("class_method={}", joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
 
        //param
        logger.info("args={}", joinPoint.getArgs());
    }
 
    @After("log()")
    public void doAfter(){
    }
 
    @AfterReturning(returning="obj", pointcut = "log()")
    public void doAfterReturnig(Object obj){
        logger.info("reponse={}", obj);
    }
}

参考文章：
1、https://blog.csdn.net/u012050154/article/details/77370297

定时任务@EnableScheduling

-启动类上加注解

@SpringBootApplication
@EnableScheduling
public class Application{
    public static void mian(String[] args){
        SpringApplication.run(Application.class,args);
    }
}

-定义一个类加注解，然后在方法上加注解

@Component
public class JobRunSchedule {
    @Scheduled(fixedRate = 5000) // 表示 每隔 5000 毫秒执行一次
    public void runScheduleJob(){
        System.out.println("任务启动"+(new Date()));
    }
}

https://blog.csdn.net/tuesdayma/article/details/81029539

@RequestBody和@RequestParam

RequestParam使用get方式
RequestBody使用post方式
与VUE集成的例子。

 @Autowired
    AdminSmUserService adminSmUserService;

    @RequestMapping(path="/checkLogin",method= RequestMethod.POST)
    public AdminSmUser checkLogin(@RequestBody AdminSmUser login, HttpServletRequest request, HttpServletResponse response){
        AdminSmUser user = new AdminSmUser();
        System.out.println("--"+login.getUserId().toString()+"  "+login.getUserPassword()
        .toString());

        Integer userIdInt =Integer.valueOf(login.getUserId());
        user = adminSmUserService.selectByPrimaryKey(userIdInt);
       

        return user;
    }

@Service

这个注解需要放在实现上才行，不能直接放在接口上。放上报错了，原因后面再找。

如果放在接口上，如果有多个实现，那么就不知道是哪个实现了。可以简单的理解Service注解要实例化对象，那么肯定不能是一个接口，必须是一个接口实现。

init-method方法afterPropertiesSet方法

1、init-method方法，初始化bean的时候执行，可以针对某个具体的bean进行配置。init-method需要在applicationContext.xml配置文档中bean的定义里头写明。例如：
这样，当TestBean在初始化的时候会执行TestBean中定义的init方法。

2、afterPropertiesSet方法，初始化bean的时候执行，可以针对某个具体的bean进行配置。afterPropertiesSet 必须实现 InitializingBean接口。实现 InitializingBean接口必须实现afterPropertiesSet方法。

3、BeanPostProcessor，针对所有Spring上下文中所有的bean，可以在配置文档applicationContext.xml中配置一个BeanPostProcessor，然后对所有的bean进行一个初始化之前和之后的代理。BeanPostProcessor接口中有两个方法： postProcessBeforeInitialization和postProcessAfterInitialization。 postProcessBeforeInitialization方法在bean初始化之前执行， postProcessAfterInitialization方法在bean初始化之后执行。

总之，afterPropertiesSet 和init-method之间的执行顺序是afterPropertiesSet 先执行，init-method 后执行。从BeanPostProcessor的作用，可以看出最先执行的是postProcessBeforeInitialization，然后是afterPropertiesSet，然后是init-method，然后是postProcessAfterInitialization。