spring
|
Java

4750 字
|
1.2 小时
本文最后更新于262 天前，其中的信息可能已经过时，如有错误请发送邮件到big_fw@foxmail.com

官网：Spring | Home

HTTP

原始

spring boot

简单参数：如果方法形参名称与请求参数名称不匹配，可以使用 @RequestParam 完成映射。

@RequestMapping("/simpleParam")
public String simpleParam(@RequestParam(name = "name") String username , Integer age){   
    System.out.println(username + " : " + age);
    return "OK";
}

@RequestParam中的required属性默认为true，代表该请求参数必须传递，如果不传递将报错。 如果该参数是可选的，可以将required属性设置为false。

文件上传

前端页面三要素

  • 表单项 type=“file”
  • 表单提交方式 post
  • 表单的enctype属性 multipart/form-data

服务端接收文件

  • MultipartFile

本地存储

@RestController
public class UploadController {
    @PostMapping("/upload")
    public Result upload(MultipartFile image) throws IOException {
        //获取原始文件名
        String originalFilename = image.getOriginalFilename();
        //构建新的文件名
        String newFileName = UUID.randomUUID().toString()+originalFilename.substring(originalFilename.lastIndexOf("."));
        //将文件保存在服务器端 D:/images/ 目录下
        image.transferTo(new File("D:/images/"+newFileName));
        return Result.success();
    }
}

在SpringBoot中，文件上传，默认单个文件允许最大大小为 1M。如果需要上传大文件，可以进行如下配置：

#配置单个文件最大上传大小
spring.servlet.multipart.max-file-size=10MB
#配置单个请求最大上传大小(一次请求可以上传多个文件)
spring.servlet.multipart.max-request-size=100MB

相关方法

  • String getOriginalFilename(); //获取原始文件名
  • void transferTo(File dest); //将接收的文件转存到磁盘文件中
  • long getSize(); //获取文件的大小，单位：字节
  • byte[] getBytes(); //获取文件内容的字节数组
  • InputStream getInputStream(); //获取接收到的文件内容的输入流

阿里云OSS

实现步骤：

定义OSS相关配置

在sky-server模块

application-dev.yml

    sky:
      alioss:
        endpoint: oss-cn-beijing.aliyuncs.com
        access-key-id: LTAI5tKX3zxirnkGEaEtv8v3
        access-key-secret: slHYRiIOQnyRZsDTZhvOW7mltS2kpT
        bucket-name: take-out-lemon

application.yml

    spring:
      profiles:
        active: dev    #设置环境
    sky:
      alioss:
        endpoint: ${sky.alioss.endpoint}
        access-key-id: ${sky.alioss.access-key-id}
        access-key-secret: ${sky.alioss.access-key-secret}
        bucket-name: ${sky.alioss.bucket-name}

读取OSS配置

//在sky-common模块中
    package com.sky.properties;

    import lombok.Data;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.stereotype.Component;

    @Component
    @ConfigurationProperties(prefix = "sky.alioss")
    @Data
    public class AliOssProperties {

        private String endpoint;
        private String accessKeyId;
        private String accessKeySecret;
        private String bucketName;

    }

生成OSS工具类对象

//在sky-server模块
    package com.sky.config;

    import com.sky.properties.AliOssProperties;
    import com.sky.utils.AliOssUtil;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;

    /**
     * 配置类，用于创建AliOssUtil对象
     */
    @Configuration
    @Slf4j
    public class OssConfiguration {

        @Bean
        @ConditionalOnMissingBean
        public AliOssUtil aliOssUtil(AliOssProperties aliOssProperties){
            log.info("开始创建阿里云文件上传工具类对象：{}",aliOssProperties);
            return new AliOssUtil(aliOssProperties.getEndpoint(),
                    aliOssProperties.getAccessKeyId(),
                    aliOssProperties.getAccessKeySecret(),
                    aliOssProperties.getBucketName());
        }
    }

AliOssUtil.java定义

    package com.sky.utils;

    import com.aliyun.oss.ClientException;
    import com.aliyun.oss.OSS;
    import com.aliyun.oss.OSSClientBuilder;
    import com.aliyun.oss.OSSException;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.extern.slf4j.Slf4j;
    import java.io.ByteArrayInputStream;

    @Data
    @AllArgsConstructor
    @Slf4j
    public class AliOssUtil {

        private String endpoint;
        private String accessKeyId;
        private String accessKeySecret;
        private String bucketName;

        /**
         * 文件上传
         *
         * @param bytes
         * @param objectName
         * @return
         */
        public String upload(byte[] bytes, String objectName) {

            // 创建OSSClient实例。
            OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);

            try {
                // 创建PutObject请求。
                ossClient.putObject(bucketName, objectName, new ByteArrayInputStream(bytes));
            } catch (OSSException oe) {
                System.out.println("Caught an OSSException, which means your request made it to OSS, "
                        + "but was rejected with an error response for some reason.");
                System.out.println("Error Message:" + oe.getErrorMessage());
                System.out.println("Error Code:" + oe.getErrorCode());
                System.out.println("Request ID:" + oe.getRequestId());
                System.out.println("Host ID:" + oe.getHostId());
            } catch (ClientException ce) {
                System.out.println("Caught an ClientException, which means the client encountered "
                        + "a serious internal problem while trying to communicate with OSS, "
                        + "such as not being able to access the network.");
                System.out.println("Error Message:" + ce.getMessage());
            } finally {
                if (ossClient != null) {
                    ossClient.shutdown();
                }
            }

            //文件访问路径规则 https://BucketName.Endpoint/ObjectName
            StringBuilder stringBuilder = new StringBuilder("https://");
            stringBuilder
                    .append(bucketName)
                    .append(".")
                    .append(endpoint)
                    .append("/")
                    .append(objectName);

            log.info("文件上传到:{}", stringBuilder.toString());

            return stringBuilder.toString();
        }
    }

controller.java实现

    @PostMapping("/upload")
    @ApiOperation("文件上传")
    public Result<String> upload(MultipartFile file){
        log.info("文件上传：{}",file);
        try {
            //原始文件名
            String originalFilename = file.getOriginalFilename();
            //文件名后缀
            String extension = originalFilename.substring(originalFilename.lastIndexOf("."));
            String objectName = UUID.randomUUID().toString() + extension;


            String filePath = aliOssUtil.upload(file.getBytes(),objectName);
            return Result.success(filePath);
        } catch (IOException e) {
            log.error("文件上传失败：{}",e);
        }
        return Result.error(MessageConstant.UPLOAD_FAILED);
    }

postman

简单参数：

如果方法形参名称与请求参数名称不匹配，可以使用 @RequestParam 完成映射。

public String simpleParam(@RequestParam(name = "name") String username , Integer age)

@RequestParam中的required属性默认为true，代表该请求参数必须传递，如果不传递将报错。 如果该参数是可选的，可以将required属性设置为false。

集合参数：

请求参数名与形参集合名称相同且请求参数为多个，@RequestParam 绑定参数关系

public String listParam(@RequestParam List<String> hobby)

日期参数：

使用 @DateTimeFormat注解完成日期参数格式转换

public String dateParam(@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime updateTime)

JSON参数：

JSON数据键名与形参对象属性名相同，定义POJO类型形参即可接收参数，需要使用 @RequestBody标识

public String jsonParam(@RequestBody User user)

路径参数：

通过请求URL直接传递参数，使用{…}来标识该路径参数，需要使用 @PathVariable 获取路径参数

@RequestMapping("/path/{id}/{name}")
public String pathParam2(@PathVariable Integer id, @PathVariable String name)

响应

@Restcontroller

类型：方法注解、类注解位置：Controller方法上/类上作用：将方法返回值直接响应，如果返回值类型是 实体对象/集合 ，将会转换为JSON格式响应说明：@RestController = @Controller + @ResponseBody ;

IOC

组件扫描

  • 前面声明bean的四大注解，要想生效，还需要被组件扫描注解@ComponentScan扫描
  • @ComponentScan注解虽然没有显式配置，但是实际上已经包含在了启动类声明注解 @SpringBootApplication 中，默认扫描的范围是启动类所在包及其子包。

Bean注入

  • @Autowired注解，默认是按照类型进行，如果存在多个相同类型的bean，将会报出错误
  • 如果同类型的bean存在多个：@Primary``@Autowired + @Qualifier("bean的名称")``@Resource(name="bean的名称")
  • @Autowired是spring框架提供的注解，而@Resource是JDK提供的注解。@Autowired 默认是按照类型注入，而@Resource默认是按照名称注入。

lombok

@Getter/@Setter为所有的属性提供get/set方法
@ToString会给类自动生成易阅读的 toString 方法
@EqualsAndHashCode根据类所拥有的非静态字段自动重写 equals 方法和 hashCode 方法
@Data提供了更综合的生成代码功能（@Getter + @Setter + @ToString + @EqualsAndHashCode）
@NoArgsConstructor为实体类生成无参的构造器方法
@AllArgsConstructor为实体类生成除了static修饰的字段之外带有各参数的构造器方法。

Mybatis

新增（主键返回)

数据封装

动态SQL

  • <if>：用于判断条件是否成立。使用test属性进行条件判断，如果条件为true，则拼接SQL。
  • <where>：where 元素只会在子元素有内容的情况下才插入where子句。而且会自动去除子句的开头的AND 或OR。
  • <set>：动态地在行首插入 SET 关键字，并会删掉额外的逗号。（用在update语句中） name like concat(‘%’,#{name},’%’)
  • <foreach> delete from emp where id in (1,2,3);
    delete from emp where id in
    #{id}

collection：集合名称item：集合遍历出来的元素/项separator：每一次遍历使用的分隔符open：遍历开始前拼接的片段close：遍历结束后拼接的片段

  • <sql>：定义可重用的 SQL 片段。
  • <include>：通过属性refid，指定包含的sql片段。 select id, username, password, name, gender, image, job, entrydate, dept_id, create_time, update_time from emp

登陆校验

会话技术

  • 会话：用户打开浏览器，访问web服务器的资源，会话建立，直到有一方断开连接，会话结束。在一次会话中可以包含多次请求和响应。
  • 会话跟踪：一种维护浏览器状态的方法，服务器需要识别多次请求是否来自于同一浏览器，以便在同一次会话的多次请求间共享数据。
  • 会话跟踪方案：
  • 客户端会话跟踪技术：Cookie
  • 服务端会话跟踪技术：Session
  • 令牌技术

JWT令牌

JWT全称：JSON Web Token （官网：https://jwt.io/）

定义了一种简洁的、自包含的格式，用于在通信双方以json数据格式安全的传输信息。由于数字签名的存在，这些信息是可靠的。

JWT的组成： （JWT令牌由三个部分组成，三个部分之间使用英文的点来分割）

  • 第一部分：Header(头）， 记录令牌类型、签名算法等。 例如：{“alg”:”HS256″,”type”:”JWT”}
  • 第二部分：Payload(有效载荷），携带一些自定义信息、默认信息等。 例如：{“id”:”1″,”username”:”Tom”}
  • 第三部分：Signature(签名），防止Token被篡改、确保安全性。将header、payload，并加入指定秘钥，通过指定签名算法计算而来。

签名的目的就是为了防jwt令牌被篡改，而正是因为jwt令牌最后一个部分数字签名的存在，所以整个jwt 令牌是非常安全可靠的。一旦jwt令牌当中任何一个部分、任何一个字符被篡改了，整个令牌在校验的时候都会失败，所以它是非常安全可靠的。

JWT工具类

public class JwtUtils {
    private static String signKey = "genius";//签名密钥
    private static Long expire = 43200000L; //有效时间
    /**
     * 生成JWT令牌
     * @param claims JWT第二部分负载 payload 中存储的内容
     * @return
     */
    public static String generateJwt(Map<String, Object> claims){
        String jwt = Jwts.builder()
                .addClaims(claims)//自定义信息（有效载荷）
                .signWith(SignatureAlgorithm.HS256, signKey)//签名算法（头部）
                .setExpiration(new Date(System.currentTimeMillis() + expire))//过期时间
                .compact();
        return jwt;
    }
    /**
     * 解析JWT令牌
     * @param jwt JWT令牌
     * @return JWT第二部分负载 payload 中存储的内容
     */
    public static Claims parseJWT(String jwt){
        Claims claims = Jwts.parser()
                .setSigningKey(signKey)//指定签名密钥
                .parseClaimsJws(jwt)//指定令牌Token
                .getBody();
        return claims;
    }
}

过滤器Filter

服务端需要统一拦截所有的请求，从而判断是否携带的有合法的JWT令牌。那怎么样来统一拦截到所有的请求校验令牌的有效性呢？这里有两种解决方案：

  1. Filter过滤器
  2. Interceptor拦截器

过滤器一般完成一些通用的操作，比如：登录校验、统一编码处理、敏感字符处理等。

基本操作

  • 第1步，定义过滤器 ：1.定义一个类，实现 Filter 接口，并重写其所有方法。
  • 第2步，配置过滤器：Filter类上加 @WebFilter 注解，配置拦截资源的路径。引导类上加 @ServletComponentScan 开启Servlet组件支持。
拦截路径urlPatterns值含义
拦截具体路径/login只有访问 /login 路径时，才会被拦截
目录拦截/emps/*访问/emps下的所有资源，都会被拦截
拦截所有/*访问所有资源，都会被拦截
@Slf4j
@WebFilter(urlPatterns = "/*") //拦截所有请求
public class LoginCheckFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws IOException, ServletException {
        //前置：强制转换为http协议的请求对象、响应对象 （转换原因：要使用子类中特有方法）
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        //1.获取请求url
        String url = request.getRequestURL().toString();
        log.info("请求路径：{}", url); //请求路径：http://localhost:8080/login
        //2.判断请求url中是否包含login，如果包含，说明是登录操作，放行
        if(url.contains("/login")){
            chain.doFilter(request, response);//放行请求
            return;//结束当前方法的执行
        }
        //3.获取请求头中的令牌（token）
        String token = request.getHeader("token");
        log.info("从请求头中获取的令牌：{}",token);
        //4.判断令牌是否存在，如果不存在，返回错误结果（未登录）
        if(!StringUtils.hasLength(token)){
            log.info("Token不存在");
            Result responseResult = Result.error("NOT_LOGIN");
            //把Result对象转换为JSON格式字符串 (fastjson是阿里巴巴提供的用于实现对象和json的转换工具类)
            String json = JSONObject.toJSONString(responseResult);
            response.setContentType("application/json;charset=utf-8");
            //响应
            response.getWriter().write(json);
            return;
        }
        //5.解析token，如果解析失败，返回错误结果（未登录）
        try {
            JwtUtils.parseJWT(token);
        }catch (Exception e){
            log.info("令牌解析失败!");
            Result responseResult = Result.error("NOT_LOGIN");
            //把Result对象转换为JSON格式字符串 (fastjson是阿里巴巴提供的用于实现对象和json的转换工具类)
            String json = JSONObject.toJSONString(responseResult);
            response.setContentType("application/json;charset=utf-8");
            //响应
            response.getWriter().write(json);
            return;
        }
        //6.放行
        chain.doFilter(request, response);
    }
     @Override //初始化方法, 只调用一次
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init 初始化方法执行了");
    }
    @Override //销毁方法, 只调用一次
    public void destroy() {
        System.out.println("destroy 销毁方法执行了");
    }
}

在上述过滤器的功能实现中，我们使用到了一个第三方json处理的工具包fastjson。我们要想使用，需要引入如下依赖：

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.76</version>
    </dependency>

拦截器Interceptor

  • 是一种动态拦截方法调用的机制，类似于过滤器。
  • 拦截器是Spring框架中提供的，用来动态拦截控制器方法的执行。

拦截器的作用：

  • 拦截请求，在指定方法调用前后，根据业务需要执行预先设定的代码。

注意：

​ preHandle方法：目标资源方法执行前执行。 返回true：放行 返回false：不放行

postHandle方法：目标资源方法执行后执行

afterCompletion方法：视图渲染完毕后执行，最后执行

  • 定义拦截器 //自定义拦截器
    @Component
    public class LoginCheckInterceptor implements HandlerInterceptor {
    //目标资源方法执行前执行。 返回true：放行 返回false：不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    System.out.println(“preHandle …. “);
    return true; //true表示放行
    }
    //目标资源方法执行,controller后执行
    @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 …. “);
    } }
  • 注册配置拦截器 @Configuration
    public class WebConfig implements WebMvcConfigurer { //拦截器对象 @Autowired private LoginCheckInterceptor loginCheckInterceptor; @Override public void addInterceptors(InterceptorRegistry registry) { //注册自定义拦截器对象 registry.addInterceptor(loginCheckInterceptor) .addPathPatterns(“/“)//设置拦截器拦截的请求路径（ / 表示拦截所有请求）
    .excludePathPatterns(“/login”);//设置不拦截的请求路径
    }
    }
拦截路径含义举例
/*一级路径能匹配/depts，/emps，/login，不能匹配 /depts/1
/**任意级路径能匹配/depts，/depts/1，/depts/1/2
/depts/*/depts下的一级路径能匹配/depts/1，不能匹配/depts/1/2，/depts
/depts/**/depts下的任意级路径能匹配/depts，/depts/1，/depts/1/2，不能匹配/emps/1

登陆校验拦截器

//自定义拦截器
@Component //当前拦截器对象由Spring创建和管理
@Slf4j
public class LoginCheckInterceptor implements HandlerInterceptor {
    //前置方式
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle .... ");
        //1.获取请求url
        //2.判断请求url中是否包含login，如果包含，说明是登录操作，放行

        //3.获取请求头中的令牌（token）
        String token = request.getHeader("token");
        log.info("从请求头中获取的令牌：{}",token);

        //4.判断令牌是否存在，如果不存在，返回错误结果（未登录）
        if(!StringUtils.hasLength(token)){
            log.info("Token不存在");
            //创建响应结果对象
            Result responseResult = Result.error("NOT_LOGIN");
            //把Result对象转换为JSON格式字符串 (fastjson是阿里巴巴提供的用于实现对象和json的转换工具类)
            String json = JSONObject.toJSONString(responseResult);
            //设置响应头（告知浏览器：响应的数据类型为json、响应的数据编码表为utf-8）
            response.setContentType("application/json;charset=utf-8");
            //响应
            response.getWriter().write(json);
            return false;//不放行
        }
        //5.解析token，如果解析失败，返回错误结果（未登录）
        try {
            JwtUtils.parseJWT(token);
        }catch (Exception e){
            log.info("令牌解析失败!");
            //创建响应结果对象
            Result responseResult = Result.error("NOT_LOGIN");
            //把Result对象转换为JSON格式字符串 (fastjson是阿里巴巴提供的用于实现对象和json的转换工具类)
            String json = JSONObject.toJSONString(responseResult);
            //设置响应头
            response.setContentType("application/json;charset=utf-8");
            //响应
            response.getWriter().write(json);
            return false;
        }
        //6.放行
        return true;
    }

过滤器&拦截器之间的区别主要是两点：

  • 接口规范不同：过滤器需要实现Filter接口，而拦截器需要实现HandlerInterceptor接口。
  • 拦截范围不同：过滤器Filter会拦截所有的资源，而Interceptor只会拦截Spring环境中的资源。

全局异常处理器

  • 定义一个类，在类上加上一个注解@RestControllerAdvice，加上这个注解就代表我们定义了一个全局异常处理器。
  • 在全局异常处理器当中，需要定义一个方法来捕获异常，在这个方法上需要加上注解@ExceptionHandler。通过@ExceptionHandler注解当中的value属性来指定我们要捕获的是哪一类型的异常。 @RestControllerAdvice
    public class GlobalExceptionHandler { //处理异常 @ExceptionHandler(Exception.class) //指定能够处理的异常类型 public Result ex(Exception e){ e.printStackTrace();//打印堆栈中的异常信息//捕获到异常之后，响应一个标准的Result return Result.error("对不起,操作失败,请联系管理员");} }

PS： @RestControllerAdvice = @ControllerAdvice + @ResponseBody

处理异常的方法返回值会转换为json后再响应给前端

事务管理

Transactional注解

@Transactional作用：就是在当前这个方法执行开始之前来开启事务，方法执行完毕之后提交事务。如果在这个方法执行的过程当中出现了异常，就会进行事务的回滚操作。

@Transactional注解：我们一般会在业务层当中来控制事务，因为在业务层当中，一个业务功能可能会包含多个数据访问的操作。在业务层来控制事务，我们就可以将多个数据访问操作控制在一个事务范围内。

@Transactional注解书写位置：

  • 方法
  • 当前方法交给spring进行事务管理
  • 类
  • 当前类中所有的方法都交由spring进行事务管理
  • 接口
  • 接口下所有的实现类当中所有的方法都交给spring 进行事务管理

说明： 可以在application.yml配置文件中开启事务管理日志，这样就可以在控制看到和事务相关的日志信息了

#spring事务管理日志 
logging: 
  level: 
   org.springframework.jdbc.support.JdbcTransactionManager: debug

rollbackFor属性

默认情况下，只有出现RuntimeException(运行时异常)才会回滚事务。

假如我们想让所有的异常都回滚，需要来配置@Transactional注解当中的rollbackFor属性，通过rollbackFor这个属性可以指定出现何种异常类型回滚事务。

 @Transactional(rollbackFor=Exception.class)

propagation属性

属性值含义
REQUIRED【默认值】需要事务，有则加入，无则创建新事务
REQUIRES_NEW需要新事务，无论有无，总是创建新事务
SUPPORTS支持事务，有则加入，无则在无事务状态中运行
NOT_SUPPORTED不支持事务，在无事务状态下运行,如果当前存在已有事务,则挂起当前事务
MANDATORY必须有事务，否则抛异常
NEVER必须没事务，否则抛异常
…

AOP

AOP的作用： 在程序运行期间在不修改源代码的基础上对已有方法进行增强（无侵入性: 解耦）

AOP的优势：

  1. 减少重复代码
  2. 提高开发效率
  3. 维护方便

连接点：JoinPoint，可以被AOP控制的方法（暗含方法执行时的相关信息）

通知：Advice，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法）

切入点：PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用

切面：Aspect，描述通知与切入点的对应关系（通知+切入点）

目标对象：Target，通知所应用的对象

导入依赖

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

通知类型

Spring中AOP的通知类型：

  • @Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行
  • @Before：前置通知，此注解标注的通知方法在目标方法前被执行
  • @After ：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行
  • @AfterReturning ： 返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行
  • @AfterThrowing ： 异常后通知，此注解标注的通知方法发生异常后执行

通知顺序

  • 目标方法前的通知方法：字母排名靠前的先执行
  • 目标方法后的通知方法：字母排名靠前的后执行

使用@Order注解，控制通知的执行顺序：

@Order(2)  //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）

切入点表达式

execution

execution(访问修饰符?  返回值  包名.类名.?方法名(方法参数) throws 异常?)

其中带?的表示可以省略的部分

  • 访问修饰符：可省略（比如: public、protected）
  • 包名.类名： 可省略
  • throws 异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）

可以使用通配符描述切入点

  • * ：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分
  • .. ：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数

切入点表达式的语法规则：

  1. 方法的访问修饰符可以省略
  2. 返回值可以使用*号代替（任意返回值类型）
  3. 包名可以使用*号代替，代表任意包（一层包使用一个*）
  4. 使用..配置包名，标识此包以及此包下的所有子包
  5. 类名可以使用*号代替，标识任意类
  6. 方法名可以使用*号代替，表示任意方法
  7. 可以使用 * 配置参数，一个任意类型的参数
  8. 可以使用.. 配置参数，任意个任意类型的参数

@annotation

自定义注解：MyLog

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {

}

切面类

@Slf4j
@Component
@Aspect
public class MyAspect {
    @Pointcut("@annotation(com.itheima.anno.MyLog)")
    private void pt(){}
    //前置通知
    @Before("pt()")
    public void before(JoinPoint joinPoint){
    }
    //后置通知
    @Before("pt()")
    public void after(JoinPoint joinPoint){
    }
    //环绕通知
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        //获取目标类名
        String name = pjp.getTarget().getClass().getName();
        log.info("目标类名：{}",name);
        //目标方法名
        String methodName = pjp.getSignature().getName();
        log.info("目标方法名：{}",methodName);
        //获取方法执行时需要的参数
        Object[] args = pjp.getArgs();
        log.info("目标方法参数：{}", Arrays.toString(args));
        //执行原始方法
        Object returnValue = pjp.proceed();
        return returnValue;
    }
}
  • 对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型
  • 对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型

配置优先级

  • 命令行（–xxx=xxx）
  • java系统属性（-Dxx=xxx）
  • application.properties
  • application.yml（主流）
  • application.yaml（忽略）

else

@ComponentScan({"com.example","com.pojo"})

@Import({}) @Enablexxx

@SpringBootApplication封装了@SpringBootConfiguration和@ComponentScan和@EnableAutoConfiguration

@EnableAutoConfiguration是实现自动化配置的核心注解

maven

一款管理和构建java项目的工具

作用

  • 方便快捷的管理项目依赖的资源(jar包)，避免版本冲突问题
  • 提供标准、统一的项目结构
  • 标准跨平台（Linux、Windows、MacOS）的自动化项目构建方式

依赖配置

依赖传递

排除依赖

依赖范围

生命周期

注意： 在同一套生命周期中，当运行后面的阶段时，前面的阶段都会运行。

执行

执行指定生命周期的两种方式：

  • 在idea中，右侧的maven工具栏，选中对应的生命周期，双击执行。
  • 在命令行中，通过命令执行。

Maven(私服)

apach-maven>conf>settings.xml

IDEA的maven工程的pom文件中配置上传（发布）地址(直接在tlias-parent中配置发布地址)

如果觉得本文对您有所帮助，那这将是对我最大的鼓励，期待您留下您宝贵的评论。
JavaSpring
暂无评论

发送评论 编辑评论 


				

			

						

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
						

					

				

				

					

						

							

								
							

							
							
													

					

				

			

			
			

				

					
				

			

				

											

							
							
						

																

							
							
						

																

							
							
						

										
					
									

			

			
			
		

	






上一篇
下一篇 

                    

                    
			        推荐文章
		            

		            

							
Java基础相关问题（总结）

							
							

							
redis基础

							
							

							
远程调用

							
							

							
Elasticsearch

							
							

							
Java集合（map、set）

							
							

							
Java集合（list）

							
							

							
javaWeb