Springboot学习总结

Springboot学习

1、@Configuration

在类上加了@Configuration注解就是配置类

2、@bean

在@Configuration注解类里面进行bean的配置，写在方法体上面

方法的返回值是对象类型， 这个对象注入到 spring ioc 容器

3、@ImportResource

@ImportResource 是导入 xml 配置，等同于 xml 文件的 resources

把其他配置文件的bean导入到此类中

@ImportResource(value = {"classpath:applicationContext.xml", "classpath:beans.xml"})

4、@PropertyResource

@PropertyResource 是读取 properties 属性配置文件

@PropertySource(value = "classpath:config.properties")

5、@Component

用注解来声明类

@Component("tiger")
public class Tiger {
    
    @Value("${tiger.name}")
    private String name;
    
    @Value("${tiger.age}")
    private Integer age;
}

6、@ComponentScan

告诉配置类@Component注解声明的类，位置在哪

@ComponentScan(basePackages = "com.bjpowernode.vo")

7、application类（@SpringBootApplication注解）

有@SpringBootApplication注解的类即是

通过这个类的主函数来启动项目

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

@SpringBootApplication注解：

​ （1）含有@Configuration，是可以作为配置文件来使用的

​ （2）含有@EnableAutoConfiguration，可以把java对象配置好，注入到spring容器中（例如mybatis）

​ （3）含有@ComponentScan，查找注解功能创建的对象，默认扫描的包是类所在的类和其子包

​ 所以application类和controller、service、dao这些包有位置规定：

​ application在主包下，其他在这个主包中的子包

8、配置文件

配置文件分为两种：properties（k=v）、yml（k：v）

properties和yml有先后顺序：properties优先于yml

（1）properties

配置文件可以设置端口号、访问应用上下文路径等等

server.port=8081
server.servlet.context-path=/springboot

（2）yml

yml需要用双空格来声明层级关系，冒号后面也需要使用一个空格来隔开

server:
  port: 8083
  servlet:
    context-path: /springboot2

9、多环境配置

可以配置多种不同的配置信息，可以方便切换

命名规则：application-环境名称.properties（yml）

配置使用方法：（这里的dev值的是application-dev中的dev）

#激活使用哪一个配置文件
spring:
  profiles:
    active: dev

10、@Value

从配置文件中提取数据

    @Value("${school.name}")
    private String name;

    @Value("${server.port}")
    private String port;

11、配置文件映射成Java对象

@ConfigurationProperties(prefix = “school”)：是从配置文件中拿取前缀为school的信息

@Component("schoolInfo")
@ConfigurationProperties(prefix = "school")
public class SchoolInfo {
    private String name;
    private Integer age;
}

使用的时候需要给对象加上自动装配（@Resource或@Autowired）

@Resource// @Autowired
private SchoolInfo info;

注意：自己配置的前缀需要添加依赖

<!--处理ConfigurationProperties有关的元数据-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

12、手动获取容器对象

// 获取容器对象
// ConfigurableApplicationContext ctx  = SpringApplication.run(Application.class, args);
ApplicationContext ctx  = SpringApplication.run(Application.class, args);

// 从容器者获取对象（因为service类加了@service("userService")注解）
UserService userService = (UserService) ctx.getBean("userService");

userService.sayHello("李四");

13、拦截器Interceptor

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z8yD3UH9-1679804174972)(C:\Users\卯末\AppData\Roaming\Typora\typora-user-images\image-20230206233159700.png)]

需要创建类去实现SpringMVC框架中的HandlerInterceptor接口

public class LoginInterceptor implements HandlerInterceptor {

    // 被拦截的控制器对象
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        System.out.println("拦截器使用");
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }
}

创建完之后需要把拦截器放到容器当中

这时候需要实现一个类，这个类实现了WebMvcConfigurer接口，这个接口中含有许多SpringMVC有关功能

其中就含有addInterceptors方法，可以添加拦截器（注意：需要加上@Configuration注解）

@Configuration
public class MyAppConfig implements WebMvcConfigurer {

    // 添加拦截器对象
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        HandlerInterceptor loginInterceptor = new LoginInterceptor();

        String path[] = {"/user/**"};
        String exPath[] = {"/user/login"};
        // 添加拦截器，指定拦截谁，排除谁(使用的数据类型应该都是数组)
        registry.addInterceptor(loginInterceptor)
            .addPathPatterns(path)
            .excludePathPatterns(exPath);

    }
}

14、过滤器Filter

经常用于处理字符编码那个

配置过程和过滤器差不多，也是生成过滤器类再设置过滤器

先继承Filter接口

public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest,
                         ServletResponse servletResponse,
                         FilterChain filterChain) throws IOException, ServletException {
        System.out.println("执行过滤器");
        // 为了传递请求（request和response）
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

再用Config类进行设置（注意：这里要使用@Configuration和@Bean）

@Configuration
public class WebApplicationConfig {
    @Bean
    public FilterRegistrationBean registrationBean() {
        FilterRegistrationBean bean = new FilterRegistrationBean();
        // 设置过滤器
        bean.setFilter(new MyFilter());
        // 过滤地址
        bean.addUrlPatterns("/user/*");
        return bean;
    }
}

编码过滤器类springboot已经准备好了：CharacterEncodingFilter

（springboot已经自动配置进去了，除非想要使用自己的字符过滤器，不然经典白雪）

// 字符编码过滤器
@Bean
public FilterRegistrationBean filterRegistrationBean(){
    FilterRegistrationBean bean = new FilterRegistrationBean();
    // 创建字符编码过滤器
    CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
    // 设置编码格式
    characterEncodingFilter.setEncoding("utf-8");
    // 指定request、response都是用encoding的值
    characterEncodingFilter.setForceEncoding(true);
    // 设置过滤器
    bean.setFilter(characterEncodingFilter);
    // 过滤地址
    bean.addUrlPatterns("/*");

    return bean;
}

还需要在配置文件中声明

#测试的配置文件

server:
  port: 8082
  servlet:
    context-path: /userTest
    # springboot默认配置了characterEncodingFilter
    # 这里的false是关闭系统自动配置的过滤器
    encoding:
      enabled: false

如果想要设置这里面自动配置好的字符过滤器，如下

server:
  port: 8082
  servlet:
    context-path: /userTest
    # springboot默认配置了characterEncodingFilter
    # 这里的false是关闭系统自动配置的过滤器
    encoding:
      enabled: true
      # 编码方式
      charset: UTF-8
      # 强制 request和 response都使用 charset属性的值
      force: true

15、mapper接口设置

分为@Mapper和@MapperScan

（1）@Mapper放在mapper接口上面，每个接口都需要这样配置

（2）@MapperScan需要在配置类Application中进行配置，包里面应该填的是数组

​ （这样就是扫描这一个包的mapper，这样就可以不配置@Mapper）

@SpringBootApplication
@MapperScan(basePackages = {"com.bjpowernode.mapper"})
public class Application {
   public static void main(String[] args) {
      SpringApplication.run(Application.class, args);
   }

}

16、mapper接口和mapper文件分离

需要在配置文件中指定mapper位置

# 指定mapper文件位置
mybatis:
  mapper-locations: classpath:mapper/*.xml
  # 指定mybatis的日志
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

17、事务支持

（1）给service类添加@Transactional 注解，实现添加事务

@Service
@Transactional // 添加事务
public class StudentServiceImpl implements StudentService{
    @Autowired
    private StudentMapper studentMapper;
    @Override
    public Student selectStudent(String id) {
        Student student = studentMapper.selectStudent(id);
        return student;
    }
}

（2）给入口类application添加@EnableTransactionManagement注解，开启事务支持

@SpringBootApplication
@EnableTransactionManagement
//@MapperScan(basePackages = {"com.learn2.mapper"})
public class LearnCode002Application {
    public static void main(String[] args) {
        SpringApplication.run(LearnCode002Application.class, args);
    }
}

（注意：@Transactional必须添加，但@EnableTransactionManagement可以省略）

18、springboot逆向工程

配置文件GeneratorMapper.xml必须生成在主目录下，和src平级

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>

    <!-- 指定连接数据库的JDBC驱动包所在位置，指定到你本机的完整路径 -->
    <classPathEntry location="D:\tools\mysql-connector-java-8.0.22.jar"/>

    <!-- 配置table表信息内容体，targetRuntime指定采用MyBatis3的版本 -->
    <context id="tables" targetRuntime="MyBatis3">

        <!-- 抑制生成注释，由于生成的注释都是英文的，可以不让它生成 -->
        <commentGenerator>
            <property name="suppressAllComments" value="true" />
        </commentGenerator>

        <!-- 配置数据库连接信息 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/springdb?useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=GMT%2B8"
                        userId="root"
                        password="123">
        </jdbcConnection>

        <!-- 生成model类，targetPackage指定model类的包名， targetProject指定生成的model放在eclipse的哪个工程下面-->
        <javaModelGenerator targetPackage="com.bjpowernode.model"
                            targetProject="D:\course\25-SpringBoot\springboot-prj\019-springboot-transactional\src\main\java">
            <property name="enableSubPackages" value="false" />
            <property name="trimStrings" value="false" />
        </javaModelGenerator>

        <!-- 生成MyBatis的Mapper.xml文件，targetPackage指定mapper.xml文件的包名， targetProject指定生成的mapper.xml放在eclipse的哪个工程下面 -->
        <sqlMapGenerator targetPackage="mapper" targetProject="src/main/resources">
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>

        <!-- 生成MyBatis的Mapper接口类文件,targetPackage指定Mapper接口类的包名， targetProject指定生成的Mapper接口放在eclipse的哪个工程下面 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.bjpowernode.dao" targetProject="src/main/java">
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>

        <!-- 数据库表名及对应的Java模型类名 -->
        <table tableName="student" domainObjectName="Student"
               enableCountByExample="false"
               enableUpdateByExample="false"
               enableDeleteByExample="false"
               enableSelectByExample="false"
               selectByExampleQueryId="false"/>
    </context>

</generatorConfiguration>

19、接口架构风格——RESTful

接口（API）：这里不是指Java语言的接口类，指的是controller中的@RequestMapper

架构风格：api组织方式

传统的架构风格：http://localhost:9002/mytrans/addStudent?name=lisi&age=26

​ （在地址上提供了 访问的资源名称addStudent, 在其后使用了get方式传递参数）

RESTful只是一种风格，不是标准，可以更加简洁，更有层次

REST：

资源使用url表示，通过名词表示资源。

在url中，使用名词表示资源， 以及访问资源的信息, 在url中，使用“ / " 分隔对资源的信息

http://localhost:8080/myboot/student/1001

​ GET：查询资源 – sql select

​ 处理单个资源： 用他的单数方式

​ http://localhost:8080/myboot/student/1001

​ http://localhost:8080/myboot/student/1001/1

​ 处理多个资源：使用复数形式

​ http://localhost:8080/myboot/students/1001/1002

​ POST：创建资源 – sql insert

​ http://localhost:8080/myboot/student

​ 在post请求中传递数据

<form action="http://localhost:8080/myboot/student" method="post">
	姓名：<input type="text" name="name" />
    年龄：<input type="text" name="age" />
  </form>

​ PUT： 更新资源 – sql update

​ “1”表示查询条件所需信息，需要添加hidden，表明是put

<form action="http://localhost:8080/myboot/student/1" method="post">
 姓名：<input type="text" name="name" />
 年龄：<input type="text" name="age" />
      <input type="hidden" name="_method" value="PUT" />
</form>

​ DELETE: 删除资源 – sql delete

​ 同更新一样

REST注解：

​ @PathVariable : 从url中获取数据

​ @GetMapping：支持的get请求方式， 等同于 @RequestMapping( method=RequestMethod.GET)

​ @PostMapping：支持post请求方式 ，等同于 @RequestMapping( method=RequestMethod.POST)

​ @PutMapping：支持put请求方式， 等同于 @RequestMapping( method=RequestMethod.PUT)

​ @DeleteMapping：支持delete请求方式， 等同于 @RequestMapping( method=RequestMethod.DELETE)

​ @RestController：符合注解， 是@Controller 和@ResponseBody组合。

​ 在类的上面使用@RestController ， 表示当前类者的所有方法都加入了 @ResponseBody

@RestController
public class MyRestController {
    @PostMapping("/student/{name}/{age}")
    public String createStudent(@PathVariable("name") String name,
                                @PathVariable("age") Integer age) {
        return "创建资源 student: name=" + name + "#age=" + age;
    }
}

**注意：**使用这种方式url要保持唯一性，不然会导致系统错误，错误如下

这里由于get请求相同，格式相同，系统分不清是使用哪一个

@GetMapping("/student/{stuId}")
public String queryStudent(@PathVariable("stuId") Integer studentId) {
    return "查询学生studentId=" + studentId;
}

@GetMapping("/student/{age}")
public String queryStudentByAge(@PathVariable("age") Integer age) {
    return "查询学生age=" + age;
}

20、Postman

测试工具

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PH8MfhYV-1679804174974)(C:\Users\卯末\AppData\Roaming\Typora\typora-user-images\image-20230210114226797.png)]

21、post转put，delete过滤器

SpringMVC中自带的过滤器

# 启用支持put、delte过滤器
spring:
  mvc:
    hiddenmethod:
      filter:
        enabled: true

这时候前端需要添加hidden

<h3>更新学生</h3>
<form action="student/1002/20" method="post">
    <input type="submit" value="注册学生">
    <input type="hidden" name="_method" value="put">
</form>

后台使用@PutMapping

@PutMapping("/student/{id}/{age}")
public String modifyStudent(@PathVariable Integer id,
                            @PathVariable Integer age) {
    return "更新资源， 执行put请求方式： id=" + id + "#age=" + age;

}

22、Redis数据库（1）

是一个NoSQL数据库，比Mysql好用，因为直接存储在内存当中，减少对数据库的直接访问

执行逻辑：

​ 先访问redis，如果没有再访问db，之后再把访问到的数据备一份到redis，方便下次使用

数据类型：

​ string，hash，set，zset，list

Redis是一个中间件：

​ 是一个独立的服务器

java中著名的客户端：

​ Jedis，lettuce，Redisson

SpringBoot中有个RedisTemplate（还有一个StringRedisTemplate），处理和redis交互

使用的是lettuce客户端库

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3fmUnsKh-1679804174974)(C:\Users\卯末\AppData\Roaming\Typora\typora-user-images\image-20230212141824925.png)]

启动服务端需要使用server（启动后不要关闭），cli是客户端（访问redis中数据）

先启动server，

再启动cli添加数据，

最启动客户端：（图形界面客户端）（需要在文件目录中执行cmd）

23、Redis数据库（2）

RedisTemplate泛型（三个其中一个，而且对象名称只能是redisTemplate）：

可以根据第一个值查取到第二个值

@Autowired
private RedisTemplate redisTemplate;

@Autowired
private RedisTemplate<String, String> redisTemplate;

@Autowired
private RedisTemplate<Object, Object> redisTemplate;

idea中使用：

@Autowired
private RedisTemplate redisTemplate;

// 添加数据到redis
@PostMapping("/redis/addstring")
public String addToRedis(String name, String value) {
    // 操作Redis中string类型数据，先获取ValueOperations对象
    ValueOperations valueOperations = redisTemplate.opsForValue();
    
    // 添加数据到redis
    valueOperations.set("myname","hhx");
    
    return null;
}

// 从redis获取数据
@GetMapping("/redis/getk")
public String getData(String k) {
    ValueOperations valueOperations = redisTemplate.opsForValue();
    Object v = valueOperations.get(k);
    return "key是" + k + ",他的值是：" + v;
}

StringRedisTemplate使用

大体和RedisTemplate相同，只是不能使用RedisTemplate<X,X>，下面是和RESTful风格的结合使用

// 使用StringRedisTemplate保存数值
@PostMapping("/redis/{k}/{v}")
public String addStringKV(@PathVariable String k,
                          @PathVariable String v) {

    // 使用StringRedisTemplate对象
    stringRedisTemplate.opsForValue().set(k, v);
    return "使用StringRedisTemplate对象";
}

// 使用StringRedisTemplate拿取数值
@GetMapping("/redis/getstr/{k}")
public String getStringValue(@PathVariable String k) {

    String v = stringRedisTemplate.opsForValue().get(k);
    return "k的value:" + v;
}

RedisTemplate 和 StringRedisTemplate对比

RedisTemplate ：把k、v经过序列化存到redis，可读性弱

StringRedisTemplate：把k、v作为String处理，使用String的序列化，可读性强

（这里用的序列话默认是jdk的序列化）

序列化的概念：

​ 序列化：按照某种规则，把对象转化为可以传输的字节序列过程

​ 反序列化：按照某种规则，把字节序列还原为对象的过程

​ 例如：ajax和java语言之间的转换