SpringBoot的配置文件、spring-data-jap实现、spring-data-redis实现、定时任务以及restful风格简介

最新推荐文章于 2022-07-12 18:06:24 发布

赵大土

最新推荐文章于 2022-07-12 18:06:24 发布

阅读量201

点赞数

文章标签： SpringBoot Restful

本文链接：https://blog.csdn.net/weixin_43647393/article/details/103381083

版权

全局配置文件

SpringBoot工程中，全局配置文件通常使用properties文件或yml文件来进行配置

文件类型：

properties文件（按点分割，效率相对较高，官方推荐）
yml文件（按冒号+缩进分割）
注：SpringBoot工程启动时默认优先加载properties文件，没有再加载yml文件

SpringBoot工程中全局配置文件默认使用以下两种命名
命名方式：

application
bootstrap

存放位置：
classpath

可配置的内容：

固定参数：
命名规则可在xx-autoconfigure.jar下META-INF下的json或properties文件中找到
自定义数据：
创建：使用key=value（properties文件）或key: value（yml文件）
使用：
在代码中使用@Value(“ ${paramName}”)注解获取在配置文件中使用$ {paramName}引用配置文件中的paramName值
在配置文件中使用随机数：（随机数主要用于SpringCloud为提供多个服务指定端口）
random.test1= ${random.int}（生成int型随机数） random.test2=$ {random.int(1,9)}（生成int型随机数，范围为[1，9]）

多环境配置（多个配置文件）:
springboot只能加载application.properties或bootstrap.propertires或application.yml或bootstrap.yml配置文件，若要加载指定配置文件需要在主配置文件中指定配置文件或在JVM启动参数中指定
步骤：
3. 创建主配置文件
4.
指定方式一：新建application.properties，使用spring.profiles.active=xx
指定方式二：使用JVM启动参数指定-Dspring.profiles.active=xx
指定方式三：通过jar包，java -jar -Dspring.profiles.active=xx xxx-xx.jar

商业开发环境演变：
5. 开发环境-本地测试
6. 测试环境-异地测试
7. 准生产环境-甲方提供的测试
8. 生产环境-上线使用

yml配置文件

文件全名是YAML（Yet Another Markup Language）
语法格式：以冒号+换行缩进+空格约束

server:
	port: 80
spring:
	driver-class-name: 
	url: 
	username: 
	password:

Spring-data-jpa

引入依赖

<?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>cn.khue</groupId>
    <artifactId>springboot-jpa-test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--test依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!--jpa依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!--mysql依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>
</project>

创建entity实体类

@Entity
@Table(name = "user")
public class User implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "uid")
    private int uid;
    private String uname;
    private String pwd;

    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", uname='" + uname + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }

    public User() {
    }

    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public String getUname() {
        return uname;
    }

    public void setUname(String uname) {
        this.uname = uname;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User entity = (User) o;
        return uid == entity.uid &&
                Objects.equals(uname, entity.uname) &&
                Objects.equals(pwd, entity.pwd);
    }

    @Override
    public int hashCode() {
        return Objects.hash(uid, uname, pwd);
    }
}

创建dao接口

@Repository
public interface UserDao extends JpaRepository<User,Integer> {
}

创建配置文件

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql:///mydb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2D8
spring.datasource.username=root
spring.datasource.password=root

创建启动类

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

创建测试类

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {SpringBootApp.class})
public class AppTest {
    @Autowired
    private UserDao userDao;

    @Test
    public void test(){
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println("\033[36m"+user+"\033[m");
        }
    }
}

测试

Spring-data-redis

引入依赖

<?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>
        <artifactId>spring-boot-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.1.10.RELEASE</version>
    </parent>

    <groupId>cn.khue</groupId>
    <artifactId>springboot-integrate-redis</artifactId>
    <version>1.0-SNAPSHOT</version>

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

创建dao接口及实现类

public interface RedisDao {
    //新增数据
    void setObject(String key,Object value);
    //查询数据
    Object getString(String key);
    //设置有效时间
    void expire(String key,long time);
    //获取剩余有效时间
    long ttl(String key);
}

@Repository
public class RedisDaoImpl implements RedisDao {

    //注入RedisTemplate
    @Autowired
    private RedisTemplate<Object,Object> redisTemplate;

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

    @Override
    public Object getString(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    @Override
    public void expire(String key,long time) {
        redisTemplate.expire(key,time, TimeUnit.SECONDS);
    }

    @Override
    public long ttl(String key) {
        return redisTemplate.getExpire(key);
    }
}

创建配置文件

#redis地址
spring.redis.host=192.168.54.40
#redis数据库
spring.redis.database=0
#redis连接端口
spring.redis.port=6379

创建启动类

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

创建测试类

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {SpringBootApp.class})
public class AppTest {
    @Autowired
    private RedisDao redisDao;

    @Test
    public void setString(){
        redisDao.setObject("strKey","strValue");
    }

    @Test
    public void getString(){
        System.out.println("\033[36m"+redisDao.getString("strKey").toString()+"\033[m");
    }

    @Test
    public void expire(){
        redisDao.expire("strKey",20);
    }

    @Test
    public void ttl(){
        System.out.println("\033[36m"+redisDao.ttl("strKey")+"\033[m");
    }
}

注意：

泛型匹配是绝对的，要么无泛型匹配，要么强泛型匹配（RedisTemplate<Object,Object>）
因为redisTemplate传输key和value使用的是jdk的序列化，所以在redis端读取该key时，必须使用双引号
jdk提供的序列化器效率低下，序列化后的数据占用空间较大，且可读性差

使用json序列化器

引入依赖

  <!--jeckson依赖-->
  <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
  </dependency>

创建一个序列化配置类

@Configuration
public class JacksonConfig {
    @Bean
    public RedisTemplate<String,Object> initRedisTemplate(RedisConnectionFactory factory){
        //指定泛型
        RedisTemplate<String,Object> redisTemplate=new RedisTemplate<>();
        //注入工厂
        redisTemplate.setConnectionFactory(factory);
        //指定key的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //指定value的序列化器
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }
}

修改泛型

	//注入RedisTemplate
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

重新运行即可

redis配置优化

#最大并发数
spring.redis.jedis.pool.max-active=7
#最大连接数
spring.redis.jedis.pool.max-idle=7
#最小连接数
spring.redis.jedis.pool.min-idle=1
#超时时长
spring.redis.jedis.pool.max-wait=5000ms

连接集群的全局配置

spring.redis.cluster.nodes=192.168.54.10:7001,192.168.54.10:7002,192.168.54.10:7003,192.168.54.10:7004,192.168.54.10:7005,192.168.54.10:7006

定时任务

引入依赖

<?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>
        <version>2.1.10.RELEASE</version>
        <artifactId>spring-boot-parent</artifactId>
    </parent>

    <groupId>cn.khue</groupId>
    <artifactId>springboot-scheduled-test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!--scheduled依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
    </dependencies>
</project>

创建定时任务类

@Component
public class MyScheduled {

    @Scheduled(cron = "* * * * * *")
    public void scheduledTest(){
        Date date = new Date();
        System.out.println("\033[36m"+date.toLocaleString()+"\033[m");
    }
}

创建启动类，开启定时环境

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

启动启动类查看测试结果

Restful风格

传统开发路径：
新增：/saveUser
更新：/updateUser
删除：/deleteUser
查询：/getUser?id=xxx
restful风格开发路径
新增：/user post请求
更新：/user put请求
删除：/user delete请求
查询：/user/{id} get请求

不以路径区分功能，以请求方式区分功能

@RestController = @Contoller+@ResposeBody
@GetMapping = @RequestMapping(method=RequestMethod.GET)
@PostMapping
@PutMapping
@DeleteMapping

赵大土

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot的配置文件、spring-data-jap实现、spring-data-redis实现、定时任务以及restful风格简介

全局配置文件SpringBoot工程中，全局配置文件通常使用properties文件或yml文件来进行配置文件类型：properties文件（按点分割，效率相对较高，官方推荐）yml文件（按冒号+缩进分割）注：SpringBoot工程启动时默认优先加载properties文件，没有再加载yml文件SpringBoot工程中全局配置文件默认使用以下两种命名命名方式：applic...
复制链接

扫一扫