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的能力约束:
- 不适合处理过于复杂的关系。 @OneToOne @OneToMany @ManyToOne @JoinColumn @JoinTable
- 效率低下。
JPA的工作流程:
- 通过注解@Repository,生成接口的动态代理。
- 解析实体类型,通过注解生成SQL语法。
- 在动态代理执行流程中,将生成的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);
}
}
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 :