Java使用小记，框架搭建看这一章就够了

Java使用小记，框架搭建看这一章就够了

注解大全

普通注解

@Controller: 用于声明Spring MVC中的控制器组件，通常与@RequestMapping注解结合使用来处理HTTP请求。

@RestController: 结合了@Controller和@ResponseBody的功能，通常用于创建RESTful API。

@Service: 用于标注业务层组件，表示定义一个服务。

@Repository: 用于标注数据访问组件，即DAO组件。

@RequestMapping: 用于映射HTTP请求到控制器方法。

@GetMapping, @PostMapping, @PutMapping, @DeleteMapping: 分别用于处理HTTP的GET, POST, PUT, DELETE请求。

@ResponseBody: 表示方法的返回值应该作为HTTP响应体返回。

@Autowired: 自动注入Spring容器中的bean。

@Qualifier: 当有多个同一类型的Bean时，可以用来指定具体的Bean。

@Bean: 用于在配置类中声明一个Bean。

@Component: 表示一个组件，Spring会自动为这些类创建bean。

@Value: 用于注入配置文件中的属性值。

数据持久化相关注解

@Entity: 表示一个JPA实体。

@Table: 指定实体对应的数据库表。

@Id: 表示实体的主键。

@GeneratedValue: 用于配置主键的生成策略。

@Column: 用于配置实体属性和数据库表的列的映射关系。

@ManyToOne, @OneToMany, @OneToOne, @ManyToMany: 用于配置实体间的关系映射。

Spring Boot特有注解

@SpringBootApplication: 用于启动Spring Boot应用的类上，包含了@ComponentScan、@Configuration和@EnableAutoConfiguration。@EnableAutoConfiguration: 启用Spring Boot的自动配置机制。

@ComponentScan: 配置组件扫描的路径。

生命周期和事件相关注解

@PostConstruct: 在Bean初始化之后执行。

@PreDestroy: 在Bean销毁之前执行。

元注解

@Retention: 指定注解的保留策略。

@Target: 指定注解的应用目标。

@Inherited: 指定注解具有继承性。

@Documented: 指定注解可以被包含在Javadoc中。

其他注解

@Override: 指定方法覆盖父类中的方法。

@Deprecated: 标记不再推荐使用的元素。

@SuppressWarnings: 指示编译器忽略特定警告。

**@JsonIgnore：**实体类中使用，让springmvc把当前对象转化为json字符串的时候，忽略该字段，最终json中不显示该字段

常用依赖

lombok依赖

1.在pom.xml中添加依赖

<!--lombok依赖-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

2.在实体类中使用，例：

import lombok.Data;

import java.time.LocalDateTime;
//lombok 在编译阶段，为实体类自动生成setter getter toString
//pom文件种引入依赖    在实体类上添加注解
@Data
public class User {
    private Integer id;//主键ID
    private String username;//用户名
    private String password;//密码
    private String nickname;//昵称
    private String email;//邮箱
    private String userPic;//用户头像地址
    private LocalDateTime createTime;//创建时间
    private LocalDateTime updateTime;//更新时间
}

注：如果接口统一使用Result返回结果，Result类中也要加@Data

validation依赖

1.在pom.xml中添加依赖

<!--validation依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

2.在使用的类上加上@Validated注解,对要校验的字段使用@Pattern,例：

@RestController
@RequestMapping("/user")
@Validated
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping("/register")
    public Result register(@Pattern(regexp = "^\\S{5,16}$") String username,@Pattern(regexp = "^\\S{5,16}$") String password) {
        //查询用户
        User u = userService.findByUserName(username);
        if (u == null) {
            //没有被占用
            //注册
            userService.register(username, password);
            return Result.success();

        } else {
            //被占用
            return Result.error("用户名已被占用");
        }
    }
}

封装返回类Result

1.创建实体类Result

package com.GUIDE.pojo;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//统一响应结果
@NoArgsConstructor
@AllArgsConstructor
@Data
public class Result<T> {
    private Integer code;//业务状态码  0-成功  1-失败
    private String message;//提示信息
    private T data;//响应数据

    //快速返回操作成功响应结果(带响应数据)
    public static <E> Result<E> success(E data) {
        return new Result<>(0, "操作成功", data);
    }

    //快速返回操作成功响应结果
    public static Result success() {
        return new Result(0, "操作成功", null);
    }

    public static Result error(String message) {
        return new Result(1, message, null);
    }
}

封装全局异常处理

1.封装GlobalExceptionHandler.java`类

package com.GUIDE.exception;

import com.GUIDE.pojo.Result;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

//全局异常处理器
@RestControllerAdvice
public class GlobalExceptionHandler {

    //参数校验失败异常处理
    @ExceptionHandler(Exception.class)
    public Result handleException(Exception e) {
        e.printStackTrace();
        return Result.error(StringUtils.hasLength(e.getMessage()) ? e.getMessage() : "操作失败");
    }
}

Md5使用

1.封装Md5Util.java类

package com.GUIDE.utils;


import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class Md5Util {
    /**
     * 默认的密码字符串组合，用来将字节转换成 16 进制表示的字符,apache校验下载的文件的正确性用的就是默认的这个组合
     */
    protected static char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};

    protected static MessageDigest messagedigest = null;

    static {
        try {
            messagedigest = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException nsaex) {
            System.err.println(Md5Util.class.getName() + "初始化失败，MessageDigest不支持MD5Util。");
            nsaex.printStackTrace();
        }
    }

    /**
     * 生成字符串的md5校验值
     *
     * @param s
     * @return
     */
    public static String getMD5String(String s) {
        return getMD5String(s.getBytes());
    }

    /**
     * 判断字符串的md5校验码是否与一个已知的md5码相匹配
     *
     * @param password  要校验的字符串
     * @param md5PwdStr 已知的md5校验码
     * @return
     */
    public static boolean checkPassword(String password, String md5PwdStr) {
        String s = getMD5String(password);
        return s.equals(md5PwdStr);
    }


    public static String getMD5String(byte[] bytes) {
        messagedigest.update(bytes);
        return bufferToHex(messagedigest.digest());
    }

    private static String bufferToHex(byte bytes[]) {
        return bufferToHex(bytes, 0, bytes.length);
    }

    private static String bufferToHex(byte bytes[], int m, int n) {
        StringBuffer stringbuffer = new StringBuffer(2 * n);
        int k = m + n;
        for (int l = m; l < k; l++) {
            appendHexPair(bytes[l], stringbuffer);
        }
        return stringbuffer.toString();
    }

    private static void appendHexPair(byte bt, StringBuffer stringbuffer) {
        char c0 = hexDigits[(bt & 0xf0) >> 4];// 取字节中高 4 位的数字转换, >>>
        // 为逻辑右移，将符号位一起右移,此处未发现两种符号有何不同
        char c1 = hexDigits[bt & 0xf];// 取字节中低 4 位的数字转换
        stringbuffer.append(c0);
        stringbuffer.append(c1);
    }

}

2.基本使用

//加密
String mdPassword= Md5Util.getMD5String(password);

ThreadLocal-线程存储

提供线程局部遍历

• 用来存取数据：set()/get()
• 使用ThreadLocal存储的数据，线程安全

1.创建ThreadLocalUtil.java类

package com.GUIDE.interceptors;

import com.GUIDE.pojo.Result;
import com.GUIDE.utils.JwtUtil;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import java.util.Map;

//创建Token拦截器
@Component
public class LoginInterceptor implements HandlerInterceptor {

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,Object handler)throws Exception{
        //令牌验证
       String token= request.getHeader("Authorization");

        //验证token
        try {
            Map<String,Object> claims= JwtUtil.parseToken(token);
            //把业务数据存储到ThreadLocal中


            //放行
            return true;
        } catch (Exception e) {
            //http响应状态码为401
            response.setStatus(401);
            //不放行
            return false;
        }
    }

}

Token使用

1.在pom.xml中添加依赖

<!--java-jwt依赖-->
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>4.4.0</version>
</dependency>

<!--单元测试的坐标-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
</dependency>

2.封装JwtUtil.java类

package com.GUIDE.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;

import java.util.Date;
import java.util.Map;

public class JwtUtil {

    private static final String KEY = "itheima";
	
	//接收业务数据,生成token并返回
    public static String genToken(Map<String, Object> claims) {
        return JWT.create()
                .withClaim("claims", claims)
                .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 12))
                .sign(Algorithm.HMAC256(KEY));
    }

	//接收token,验证token,并返回业务数据
    public static Map<String, Object> parseToken(String token) {
        return JWT.require(Algorithm.HMAC256(KEY))
                .build()
                .verify(token)
                .getClaim("claims")
                .asMap();
    }

}

3.基本使用-生成token

//登录成功-调用token类
Map<String, Object> claims = new HashMap<>();
claims.put("id", Pageuser.getId());
claims.put("username", Pageuser.getUsername());

String token = JwtUtil.genToken(claims);

return Result.success(token);

SpringBoot集成Redis

1.在pom.xml中添加依赖

<!--Redis依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2.在application.yml中配置连接地址

spring:
  data:
    redis:
      host: localhost
      port: 6379

3.存储/获取数据

package com.GUIDE;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

import java.util.concurrent.TimeUnit;

@SpringBootTest //如果在测试类上添加了这个注解，那么将来单元测试方法执行之前，会先初始化Spring容器
public class RedisTest {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    //存储数据
    @Test
    public void testSet() {
        //往Redis里添加一个键值对 stringRedisTemplate
        ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();

        operations.set("name", "郭源潮"); //存储
        operations.set("id", "111",15, TimeUnit.SECONDS); //时效存储
    }

    //获取数据
    @Test
    public void testGet() {
        //往Redis里添加一个键值对 stringRedisTemplate
        ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();

        System.out.println(operations.get("name"));
    }
}

创建拦截器

集成token，ThreadLocal，redis

1.新建interceptors文件夹,然后新建LoginInterceptor类

package com.GUIDE.interceptors;

import com.GUIDE.pojo.Result;
import com.GUIDE.utils.JwtUtil;
import com.GUIDE.utils.ThreadLocalUtil;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import java.util.Map;
import java.util.concurrent.TimeUnit;

//创建Token拦截器
@Component
public class LoginInterceptor implements HandlerInterceptor {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //令牌验证
        String token = request.getHeader("Authorization");

        //验证token
        try {
            //redis中获取相同的token
            ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();
            String redisToken = operations.get(token);
            if (redisToken == null) {
                //token失效
                throw new RuntimeException();
            }

            Map<String, Object> claims = JwtUtil.parseToken(token);
            //把业务数据存储到ThreadLocal中
            ThreadLocalUtil.set(claims);

            //放行
            return true;
        } catch (Exception e) {
            //http响应状态码为401
            response.setStatus(401);
            //不放行
            return false;
        }

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //清空ThreadLocal中的数据
        ThreadLocalUtil.remove();
    }
}

2.新建config文件夹，新建WebConfig类—注册拦截器

package com.GUIDE.config;

import com.GUIDE.interceptors.LoginInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    //注入
    @Autowired
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //登录/注册接口不拦截
        registry.addInterceptor(loginInterceptor).excludePathPatterns("/user/login", "/user/register");
    }
}

多环境开发-Pofiles

开发-测试-生产

1.新建对应的yaml文件，例：

application.yaml  ---基础
application-test.yaml	---测试
application-local.yaml	---开发
application-prod.yaml	---生产

2.在基础yaml中指定开发环境

spring:
  profiles:
    active: local

项目打包

添加插件

1.在pom.xml中添加依赖—在project下级

<build>
    <plugins>
    <!--打包插件-->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>3.3.2</version>
        </plugin>
    </plugins>
</build>

启动package

• 右侧Maven
• 点击Maven工程
• 点击生命周期
• 最好先双击clear然后在双击package打包

运行打包文件

• 注意端口号
• jar包部署，要求服务器必须有jre环境

在文件中cmd输入

运行：java -jar 打包文件全称

命令行参数方式

1.cmd:–键=值

例：运行并修改端口号：java -jar 打包文件全称 --server.port=9999

2.使用系统环境变量，注意变量和值要和SpringBoot中键值保持一致

外部配置文件方式

在打包文件下新建一个application.yml文件，在文件中可批量修改配置信息

配置优先级

1. 项目中resources目录下的application.yml
2. Jar包所在目录下的application.yml
3. 操作系统的环境变量
4. 命令行参数

其他错误

Rdis闪退

目录下：cmd输入redis-cli.exe
127.0.0.1:6379> shutdown
not connected> exit

Rdis乱码

cmd打开控制台后

先输入chcp 65001，修改控制台的编码格式为UTF-8

然后再输入redis-cli --raw

后面正常查询，就能得到想要的中文结果了

实体类报错

在实体类中使用@Data会自动帮我们生成set/get方法

修改实体类后要在Maven中双击compile重新生成