springboot项目定义全局变量 springboot创建全局变量

1.SpringBoot全局配置文件

1.全局配置文件2种类型

1.properties----key value
2.yml

配置文件的命名都是application|bootstarp,所在位置都是在classpath

全局配置文件配置内容：
1.固定参数 —META-INF/spring-configuration-metadata.json
2.自定义数据

引用

//在配置文件中
	my.test.str=testString
	my.test.str1=${my.test.str}
	 # 随机数--->应用场景：springcloud中对服务的管理是基于命名的，那么端口号不重要，可以使用随机数提供端口号
	my.1=${}
  	my.2=${(1,9)}
 	在.java文件中
 	@Value("${my.test.str}")
    private String str;
    @Value("${my.test.str1}")
    private String str1;
    @Value("${my.1}")
    private String int1;
    @Value("${my.2}")
    private String int2;

SpringBoot多环境启动支持命令选择环境，就是在工程中不提供application.xxx配置文件，直接提供application-dev.xxx，application-prod.xxx等配置文件，在启动工程应用的时候，通过启动参数来决定具体的环境。命令为： java -jar xxx.jar --spring.profiles.active=dev

springboot启动时只加载bootstrap.properties和application.properties
可以再配置文件中增加一个配置，指定springboot再次加载一个新的扩展配置
spring配置激活哪一个配置文件
1.对应的值是环境命名，对等的扩展配置就是application-环境名.properties
spring.profiles.active=test

2.也可以通过JVM启动参数定义激活参数的环境
配置方式：
run-->configuration-->Dspring.profiles.active=环境名

3.也可以打包成jar，通过java  -jar  Dspring.profiles.active=环境名 来激活的环境
打包插件进行打包jar

传参–传给jvm
–传给主方法
商业开发->
开发，配置文件 dev
测试，配置文件 test
准生产，配置文件 testProd
生产,配置文件 prod

yml配置文件–具备树形结构

在：后面一定要加一个空格

server:
  port: 82
  
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2D8
    username: root
    password: root
    
mybatis:
  type-aliases-package: com.bjsxt.entity

my:
  test:
    str: testDevEnvo
    str1: ${my.test.str}
    
  random:
    int1: ${(1,9)}
    int2: ${(1,9)}

注意：在yml文件和properties同时存在时，properties的优先级高一些

2.spring-data-jpa

spring-data-jpa 是基于Hibernate实现数据库访问的方式，开发简单，效率低下，在互联网中一般不使用

JPA的能力约束：

1. 不适合处理过于复杂的关系。 @OneToOne @OneToMany @ManyToOne @JoinColumn @JoinTable
2. 效率低下。

JPA的工作流程：

1. 通过注解@Repository，生成接口的动态代理。
2. 解析实体类型，通过注解生成SQL语法。
3. 在动态代理执行流程中，将生成的SQL发送到数据库。

1.pom.xml

2.创建实体类User—

package com.bjsxt.entity;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Objects;
/**
 * @Entity - 代表当前的类型是一个实体，可以作为数据库读写操作的数据载体
 * @Table - 描述当前类型和数据库中的哪一个表对应。
 */
@Entity
@Table(name = "my_user")
public class User implements Serializable {
    /**
     * @Id - 表示当前的属性是对应数据库PK字段的属性。
     * @Column - 描述当前属性和数据库表中的哪一个字段对应，如果属性名
     *     和字段名一致，可以省略此注解。
     * @GeneratedValue - 主键生成策略，属性strategy代表具体的生成策略方案。如果是代码生成主键，则不需要
     *     提供此注解。
     *  GenerationType.IDENTITY - 自增长
     *  GenerationType.AUTO - 自动， 就是使用数据库的默认生成策略，如：mysql就是自增，oracle就是序列
     *  GenerationType.SEQUENCE - 使用序列sequence做为主键的生成策略。
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;

    @Column(name="username")
    private String username;
    private String password;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(id, user.id) &&
                Objects.equals(username, user.username) &&
                Objects.equals(password, user.password);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, username, password);
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public User() {
    }

    public User(Integer id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }
}

3.创建接口UserDao—访问数据库，做用户数据的读取操作

package com.bjsxt.dao;

import com.bjsxt.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * 访问数据库，做用户数据读写操作的。
 * 学习JDBC过程中，接口要定义CRUD方法。
 *
 * JPA开发中，Dao是通过继承方式提供默认的，通用的CRUD操作。
 * JpaRepository接口的泛型 <实体类型，主键属性类型>
 * 需要使用@Repository注解描述，代表当前的接口由Spring-Data-JPA提供动态代理实现。
 */
public interface UserDao extends JpaRepository<User,Integer> {

}

4.配置文件

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.password=root
spring.datasource.username=root
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2D8
# 显示sql语句
spring.jpa.show-sql=true
# 自动创建表格
spring.jpa.hibernate.ddl-auto=update

5.启动类

package com.bjsxt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class JpaApp {
    public static void main(String[] args) {
        SpringApplication.run(JpaApp.class,args);
    }
}

6.测试类

package com.bjsxt.test;

import com.bjsxt.JpaApp;
import com.bjsxt.dao.UserDao;
import com.bjsxt.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

@RunWith(value = SpringRunner.class)
@SpringBootTest(classes = JpaApp.class)
public class TestJpa {
    @Autowired
    private UserDao userDao;

    @Test
    public void testSave(){
        User user = new User();
        user.setUsername("jpa");
        user.setPassword("jpa");
        user = userDao.save(user);
        System.out.println(user);
    }

    @Test
    public void testFind(){
        List<User> userList = userDao.findAll();
        for(User user:userList){
            System.out.println(user);

        }

    }
}

3.Springboot-data-redis

spring-data-redis：spring社区提供的一个访问redis的快速操作框架。
spring-data：是spring社区提供的一个顶级工程。和springframework、springboot、springcloud平级。其中提供若干二级工程，用于访问对应的不同的数据源。如：spring-data-jpa依托于Hibernate底层实现，快速访问数据库（RDBMS）、spring-data-redis依托于jedis底层实现，快速访问redis缓存服务、spring-data-mongodb依托于mongodb-java-client底层实现，快速访问mongodb分布式文件数据库。
所有的spring-data子工程，其提供的API都是依托于模板设计模式实现的。提供的访问数据源的第一客户端类型基本都是XxxTemplate。
模板设计模式：面向接口开发，先定义若干接口，接口可以实现某功能。但是不提供具体的实现逻辑。Template面向接口开发，直接应用接口的定义方法，实现逻辑过程。

配置pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http:///POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http:///POM/4.0.0 http:///xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.10.RELEASE</version>
    </parent>

    <groupId>com.bjsxt</groupId>
    <artifactId>springboot-data-redis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
		<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
    </dependencies>

</project>

创建接口及实现类

package com.bjsxt.dao;

public interface RedisDao {
    //设值
    void set(String key,String value);
    void set(String key,Object value);
    //获取
    Object get(String key);
    //设值有效时长
    void expire(String key,int time);
    //获取剩余有效时长
    long ttl(String key);
}

package com.bjsxt.dao.impl;

import com.bjsxt.dao.RedisDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;

import java.util.concurrent.TimeUnit;
@Repository
public class RedisDaoImpl implements RedisDao {

    /**
     * 泛型的匹配是绝对的
     * 要么无泛型约束，要么泛型强约束
     *
     * SpringBoot容器准备的默认的RedisTemplate具体类型是：
     * RedisTemplate< Object,Object >---强类型，不完全匹配，则无法注入
     *
     * 使用RedisTemplate<Object,Object>保存到redis中的数据，通过客户端访问时，key数据必须使用双引号才可以访问
     * 因为RedisTemplate<Object,Object>使用的序列化方式是jdk提供的
     *
     */
    @Autowired
    private RedisTemplate<Object,Object> template;

    @Override
    public void set(String key, String value) {
        this.template.opsForValue().set(key,value);
    }

    @Override
    public void set(String key, Object value) {
        this.template.opsForValue().set(key,value);
    }

    @Override
    public Object get(String key) {
        Object value = this.template.opsForValue().get(key);
        return value;
    }

    @Override
    public void expire(String key, int time) {
        this.template.expire(key,time, TimeUnit.SECONDS);
    }

    @Override
    public long ttl(String key) {
        Long expire = this.template.getExpire(key);
        return expire;
    }
}

配置文件

spring.redis.host=192.168.54.60
spring.redis.port=6379
spring.redis.database=0
spring.redis.timeout=5000

启动类----》EnableRedisRepositories----开启spring-data-redis环境

package com.bjsxt.dao;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;

/**
 * @EnableRedisRepositories 开启spring-data-redis的环境
 * springboot自动准备RedisTemplate
 * 根据application.properties配置文件，创建RedisConnectionFactory
 * 创建RedisTemplate对象，并将RedisConnectionFactory赋值到template对象的属性中
 */
@SpringBootApplication
@EnableRedisRepositories
public class RedisApp {
    public static void main(String[] args) {
        SpringApplication.run(RedisApp.class,args);
    }
}

测试类

package com.bjsxt.test;

import com.bjsxt.dao.RedisApp;
import com.bjsxt.dao.RedisDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(value = SpringRunner.class)
@SpringBootTest(classes = {RedisApp.class})
public class TestRedis {
    @Autowired
    private RedisDao redisDao;

    @Test
    public void testSetString(){
        this.redisDao.set("strKey","strValue");
    }
    @Test
    public void testGetString(){
        System.out.println(this.redisDao.get("strKey"));
    }
 @Test
    public void testExpire(){
        this.redisDao.expire("strKey",100);
    }
    @Test
    public void testTtl(){
        System.out.println(this.redisDao.ttl("strKey"));;
    }
}

redis存java对象----必须序列化，默认使用jdk 序列化的方式
创建实体类对象

package com.bjsxt.entity;

import java.io.Serializable;
import java.util.Objects;

public class User implements Serializable {
    private Integer id;
    private String username;
    private String password;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return Objects.equals(id, user.id) &&
                Objects.equals(username, user.username) &&
                Objects.equals(password, user.password);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, username, password);
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public User() {
    }

    public User(Integer id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }
}

测试对象的获取

@Test
    public  void testsetObject(){
        User user = new User();
        user.setId(10);
        user.setUsername("admin");
        user.setPassword("123");
        this.redisDao.set("userKey",user);
    }

    @Test
    public void testGetObject(){
        System.out.println(this.redisDao.get("userKey"));
    }

jdk提供的序列化器效率低，和java对象与json字符串转换效率比较，低10~100倍
序列化的对象越多，效率越低

解决----自定义自己的序列化器
使用Jackson-databind,提供启动的配置类
RedisConfiguration.java

package com.bjsxt;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfiguration {

    /**
     * @Bean 相当于定义bean标签，spring容器管理对象的时候实现自动装配DI
     * @Bean 也可以实现自动装配，其类型对应的java对象只要在容器中存在，即自动注入
     * 如果同类型对象有多个，根据参数名称，找同名对象注入
     * 如果同类型对象有多个，且没有同名对象，则抛出异常
     *
     * @param connectionFactory
     * @return
     */

    @Bean
    public RedisTemplate<String,Object> geneRedisTemplate(RedisConnectionFactory connectionFactory){
        RedisTemplate<String,Object> template = new RedisTemplate<>();

        template.setConnectionFactory(connectionFactory);

        //专门处理字符串类型的序列化器相当于toString方法
        template.setKeySerializer(new StringRedisSerializer());
        //将java对象和json对象相互转换的序列化器
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());

        return template;
    }
}

优化redis连接池，springboot环境中，默认是没有redis连接池

# 最大并发数---同时处理的redis连接数量小于等于max-idle数量
spring.redis.jedis.pool.max-active=8
# 最大连接数
spring.redis.jedis.pool.max-idle=8
# 最小连接数
spring.redis.jedis.pool.min-idle=1
# 等待时长
spring.redis.jedis.pool.max-wait=1000
# 最大活动数
spring.redis.jedis.pool.max-total=8

4.springboot定时任务

1.创建定时任务类

package com.bjsxt.sch;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * 编写定时任务
 *
 */
@Component
public class MyTask {
    /**
     * 定时任务
     * 每秒执行一次，向控制台输出时间
     * 秒 分 时 天 月 周 年
     */
    @Scheduled(cron = "* * * * * *")
    public void firstTask(){
        Date date = new Date();
        System.out.println(date);

    }
}

2.启动类
需要spring环境提供一个定时任务的环境，需要开启对应的注解@EnableScheduling

package com.bjsxt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

/**
 * 需要spring容器提供一个定时任务环境，需要开启对应的注解@EnableScheduling
 */
@SpringBootApplication
@EnableScheduling
public class SchApp {
    public static void main(String[] args) {
        SpringApplication.run(SchApp.class,args);
    }
}

5.restful风格

restful：不以路径区分功能，以请求方式区分功能
传统开发路径：
新增：/saveUser
更新：/updateUser
删除：/deleteUser
查询：/getUser?id=xxx
restful开发路径
新增：/user —post请求
更新：/user —put请求
删除：/user —delete请求
查询：/user/{id} —get请求

@Controller
@RestController 不需要写@ResponseBody
@RequestMapping 描述类型，方法
@GetMapping 描述的方法必须是get请求
@RequestParam 方法参数
@PathVariable 方法参数----路径中有参数
@PostMapping
@PutMapping
@DeleteMapping

localhost—127.0.0.1
0.0.0.0
本机IP
主机名

监控

Actuator插件

导入依赖jar包

<!-- actuator插件 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-actuator</artifactId>
		</dependency>

配置文件

# 配置监控actuator开启的终端节点地址，就是对外开放什么访问权限
# 客户端可以通过http协议访问
management.endpoint.web.exposure.include=*

Actuator插件提供的url ：

Spring Boot Admin监控工具