SpringBoot学习（二）

一时失言乱红尘 2023-06-19 02:27 20阅读 0赞

## 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.random.int1=${random.int}
      	my.random.int2=${random.int(1,9)}
     	在.java文件中
     	@Value("${my.test.str}")
        private String str;
        @Value("${my.test.str1}")
        private String str1;
        @Value("${my.random.int1}")
        private String int1;
        @Value("${my.random.int2}")
        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: ${random.int(1,9)}
        int2: ${random.int(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://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/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);
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzY2NjA1MQ_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzY2NjA1MQ_size_16_color_FFFFFF_t_70 1]

## 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包

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

配置文件

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

**Actuator插件提供的url ：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzY2NjA1MQ_size_16_color_FFFFFF_t_70 2]

### Spring Boot Admin监控工具 ###

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzY2NjA1MQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191205201159926.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzY2NjA1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzY2NjA1MQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191205201229299.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzY2NjA1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzY2NjA1MQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191205101750415.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzY2NjA1MQ==,size_16,color_FFFFFF,t_70