springboot-study

最新推荐文章于 2024-04-21 09:50:22 发布

gsy_study

最新推荐文章于 2024-04-21 09:50:22 发布

阅读量616

点赞数

文章标签： SpringBoot

本文链接：https://blog.csdn.net/gsy_study/article/details/102840807

版权

使用@ConfigurationProperties赋值给实体类

profile 配置文件

整合测试

扫描包，启动项目

controller 和 Restcontroller

resultType 和 resultMap的区别

Springboot 优点

为基于Spring的开发提供更快的入门体验
开箱即用，没有代码生成，也无需XML配置。同时也可以修改默认值来满足特定的需求
提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等
SpringBoot不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式

SpringBoot的核心功能

起步依赖
起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。
自动配置
Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪
以上原文链接：https://blog.csdn.net/qq_36821220/article/details/102674358.

入门程序

helloword报错，页面显示不出来,是因为在pom.xml中引入了security依赖

pom.xml中配置信息
···

<parent><!-- 父级依赖,所有springboot功能必须继承 spring-boot-starter-parent-->
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.2.0.RELEASE</version>
	<relativePath/> <!-- lookup parent from repository -->
</parent>

<!-- 使用SpringMVC和Spring的jar包 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>

···
编写一个HelloWorld

新建controller下的Helloworld类

// HelloWorld.java
@Controller
public class HelloWorld {
	@RequestMapping("/")
	@ResponseBody
	public String say() {
		return "Hello World";
	}

}

//DemoApplication.java
//入口
@SpringBootApplication
public class DemoApplication {
//入口
	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}

在入口中点击导航的小蜘蛛图标
在这里插入图片描述
下方cosole控制台中显示如下图，则表明开启成功

//启用自动配置
@EnableAutoConfiguration

Starter Pom

Starter Poms是可以包含到应用中的一个方便的依赖关系描述符集合。可以获取所有Sping及相关技术得意展会服务，不需要拷贝大量依赖关系代码。
staters遵循一个相似的命名模式：spring-bbot-starter-*
例如
一些常见的依赖

spring-boot-starter：核心Spring Boot starter，包括自动配置支持，日志和YAML
spring-boot-starter-data-jpa：对”Java持久化API”的支持，包括spring-data-jpa，spring-orm和Hibernate
spring-boot-starter-thymeleaf：对Thymeleaf模板引擎的支持，包括和Spring的集成
spring-boot-starter-web ：对全栈web开发的支持，包括Tomcat和spring-webmvc

全局配置文件

必须写在application.文件中,放在resources文件下
在这里插入图片描述
以修改配置默认端口号和路径为例

通过application.properties

server.port=8088
server.context-path=/hello

通过application.yml
注意：冒号:后面必须有一个空格

server:
  port: 8088
  context-path: /hello

再次访问时，访问 localhost:8088/hello.

yml配置数组数据

#配置数据、集合(配置普通字符串)
city: 
	- beijing
	- tianjin
	- shanghai
	- 
#city: [beijing,tianjin,shanghai]

#配置对象集合数据
student:
	- name: tom
	  age: 18
	- name: lucy
	  sg2:19
#student: [{name: tom,age: 18},{name: lucy,age: 19}]

先加载yml文件，在加载properties

获取自定义配置的值

通过@Value映射

在source包下的application.yml下写自定义配置文件(以yml为例，也可以写在application.properties里)

book:
  author:gsy
  name:springboot

配置文件的内容之后，获取值有两种方法
- 写在controller中

@Controller
public class BookController {

	//获取值
	@Value("${book.author}")
	private String author;
	
	@Value("${book.name}")
	private String name;
	
	@RequestMapping("/book")
	@ResponseBody
	public String say() {
		return author+":"+name;
	}
	
	
}

使用@ConfigurationProperties赋值给实体类

创建实体类

//把普通pojo实例化到spring容器中，相当于配置文件中的<bean id="" class=""/>
//@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。 
@Component
//类型安全配置，减少value的重复使用带来的麻烦
@ConfigurationProperties(prefix = "book")
public class BookDao {
 private String name;
 private String author;
 public String getName() {
 	return name;
 }
 public void setName(String name) {
 	this.name = name;
 }
 public String getAuthor() {
 	return author;
 }
 public void setAuthor(String author) {
 	this.author = author;
 }
 
 

}

controller中

@Controller
public class BeanController {
//	自动注入
	@Autowired
	private BookDao bookDao;
	@RequestMapping("/a")
	public String getBook() {
		return bookDao.getAuthor()+":"+bookDao.getName();
	}

profile 配置文件

profile是针对不同环境（开发测试生产）对不同的配置进行支持。
例如在sources下
palication-dev.properties代表开发环境下的配置文件
palication-sit.properties代表测试环境下的配置文件
palication-prod.properties代表生产环境下的配置文件
如何使用呢？
需要创建一个全局的配置文件 Application.properties
在里面通过写入spring.profiles.active=dev来告诉使用的配置文件是开发环境下的。

整合测试

测试“Hello”输出是否正确

@Controller
public class TestController {
	@RequestMapping("/test")
	@ResponseBody
	public String yes() {
		return "Hello";
	}
}

在src\test\java中进行测试

/指明要测试谁
@SpringBootTest(classes = Test.class)
//指明进行测试的类是谁
@RunWith(SpringJUnit4ClassRunner.class)
//和web的整合
@WebAppConfiguration
public class TestHello {

//	注入Test对象
	@Autowired
	private TestController testController;
//断言测试
	@Test
	public void testh() {
		TestCase.assertEquals(this.testController.yes(), "Hello");
	}

}

在测试方法中右键testh选择Run As -> JUnit Test

扫描包，启动项目

@SpringBootApplication = @EnableAutoConfiguration+ @ComponentScan("com.example.test.controller")


//默认情况下扫描的都是当前包及当前包的子包
//组合注解
@SpringBootApplication(scanBasePackageClasses = {"com.example.test.controller"})
//如果是子包，就不用指定包名

//@EnableAutoConfiguration
//指明controller所在的包，进行扫描
//@ComponentScan("com.example.test.controller")
public class TestApplication {

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

controller 和 Restcontroller


//如果每个功能返回的都是Restfull内容，那么可以使用该注解
@RestController
//@Controller
public class TestController {
	@RequestMapping("/test")
//	返回的是Restful，不使用该注解跳转
//	@ResponseBody
	public String yes() {
		return "Hello";
	}
	
	@RequestMapping("/ok")
//	@ResponseBody
	public String ok() {
		return "ok";
	}
}

什么是Restfull？
见连接https://www.cnblogs.com/potato-chip/p/9031808.html.

支持Rest风格

//	支持Rest风格
	@RequestMapping("/info/{msg}")
//	@PathVariable 负责把url中输入的msg传进参数
	public String showInfo(@PathVariable String msg) {
		return "show" + msg;
	}

在浏览器中输入localhost:8080/info/haha.
看到页面显示 showhaha

把工程设置为开发模式

只需要在pom.xml添加下列依赖

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>springloaded</artifactId>
    </dependency>
    
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
    </dependency>

访问静态资源

静态资源放到这几个目录下，springboot会自动扫描到

“classpath:/META-INF/resources/”,
“classpath:/resources/”,
“classpath:/static/”,
“classpath:/public/”
“/”：当前项目的根路径

一般static文件中方js，css，图片，templates存放html页面
访问 http://localhost:8080/1.png.会出现图片
但是如果访问 http://localhost:8080/index.html.会出现如下页面

我在我的controller类里进行修改,在tenplates中新建一个login.html

@Controller
public class HelloWorld {
	@RequestMapping("/login")
	// @ResponseBody
	public String login() {
		return "index";
	}
	@RequestMapping("/")
	public String index() {
	    return "index";
	}

}

注：@ResponseBody 返回的是json，如果想输入http://localhost:8080/login.
进入login.html界面，需要去掉@ResponseBody 这个注解
此时访问http://localhost:8080/.会出现在index.html中写入的内容。
这一系列的访问似乎没有在访问的时候写static，resources这些文件路径，这是为什么呢？
在访问源码之前，我们先看一下自定义文件夹访问静态资源的方式

@Configuration
public class WebConfigurer extends WebMvcConfigurerAdapter{
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/test/**").addResourceLocations("classpath:/templates/");
        super.addResourceHandlers(registry);
    }

}

之后再访问 http://localhost:8080/test/login.html.会显示login页面的内容
不难看出，addResourceHandler("/test/**")提供资源访问路径，addResourceLocations(“classpath:/templates/”);是本地项目路径
=查看源码
具体介绍看原文链接 https://blog.csdn.net/qq_34797335/article/details/80194137.

#配置静态资源访问路径

spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/,classpath:/templates/

自定义消息转换器

springboot已经做默认处理了，默认配置了消息转换器。

//    定义消息转换器
    @Bean
    public StringHttpMessageConverter stringHttpMessageConverter() {
        StringHttpMessageConverter convert = new StringHttpMessageConverter(Charset.forName("UTF-8"));
        return convert;
    }

@Bean一定要加上，这样springboot才能识别

Json解析

在springboot中，默认配置Jackson.
需要包：
jackson-core-2.2.3.jar（核心jar包）
jackson-annotations-2.2.3.jar（该包提供Json注解支持）
jackson-databind-2.2.3.jar
原文章连接链接: https://www.jianshu.com/p/3931b3b6e7b6.

实现使用FastJson解析Json数据

将FastJson的依赖放到pom.xml中

//FastJson依赖
<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
           //注意版本号
            <version>1.2.15</version>
   </dependency>

在dao中创建Person实体类

package com.example.demo.dao;

import java.sql.Date;

public class Person {
    private int id;
    private String name;
    private Date date;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getDate() {
        return date;
    }
    public void setDate(Date date) {
        this.date = date;
    }
    

}

在controller类里返回实体类对象

@Controller
public class PersonController {
    
//    @Autowired
//    private Person person;
    @RequestMapping("/person")
    @ResponseBody
    public Object show() {
        Person person = new Person();
        person.setId(666);
       person.setName("gsy");
       person.setDate(new Date());
       return person;
      
    }

配置FastJson有两种方式
- 第一种是让启动类继承WebMvcControllerAdapter

SpringBootApplication
public class DemoApplication extends WebMvcConfigurerAdapter{
//    重写里面的方法  
//    注意重写的是configureMessageConverters这个方法
@Override
   public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
//        创建FastJson的消息转换器
       FastJsonHttpMessageConverter convert = new FastJsonHttpMessageConverter();
//        创建FastJson的配置对象
       FastJsonConfig config = new FastJsonConfig();
//        对Json数据格式化
       config.setSerializerFeatures(SerializerFeature.PrettyFormat);
//        把配置对象给converter转换器
       convert.setFastJsonConfig(config);
//        把convert加到converters集合里
       converters.add(convert);
       
       
   }

在浏览器输入 http://localhost:8080/person.
结果：
{ “date”:1571903802600, “id”:666, “name”:“鑰侀儹” }
出现乱码
解决办法：
在全局配置文件application.properties中加入
spring.http.encoding.force=true就会变成正常汉字
{ “date”:1571903933576, “id”:666, “name”:“老郭” }

//    规定日期格式
    @JSONField(format = "yyy-MM-dd HH")

{ “date”:“2019-10-24 17”, “id”:666, “name”:“老郭” }

第二种是通过@Bean写一个HttpMessageConverter<?>类型的转换器

public class DemoApplication{
    @Bean
    public HttpMessageConverters fastJsonMessageConverter(){
//      创建FastJson的消息转换器
      FastJsonHttpMessageConverter convert = new FastJsonHttpMessageConverter();
//      创建FastJson的配置对象
      FastJsonConfig config = new FastJsonConfig();
//      对Json数据格式化
      config.setSerializerFeatures(SerializerFeature.PrettyFormat);
//      把配置对象给converter转换器
      convert.setFastJsonConfig(config);
      HttpMessageConverter<?> con = convert;
      return new HttpMessageConverters(con);
      
    }

整合mybatis

用的数据库是h2数据库，具体使用方法见https://jingyan.baidu.com/article/c275f6ba607282e33d756784.html.

导入依赖

<!-- mybatis依赖 -->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.1.1</version>
		</dependency>
         <!-- ali数据源连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
           <version>1.0.25</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <!-- h2数据库 -->
         <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>

application.yml中配置数据库信息

server:
    port: 8080
spring:
    jpa:
        database: h2
        show-sql: true
        generate-ddl: false
        hibernate:
            ddl-auto: none
    #主要部分
    datasource:
        url: jdbc:h2:mem:test;DB_CLOSE_DELAY=-1
        driver-class-name: org.h2.Driver
        username: sa
        password: 123456
    h2:
        console:
            path: /h2-console
            enabled: true

h2数据源配置

#配置数据库信息
server:
   port: 8080
spring:
   jpa:
       database: h2
       show-sql: true
       generate-ddl: false
       hibernate:
           ddl-auto: none
   datasource:
       url: jdbc:h2:file:C:/H2/mybatis
       driver-class-name: org.h2.Driver
       username: sa
       password: 123456
   h2:
       console:
           path: /h2-console
           enabled: true

mysql druid数据源配置https://www.jb51.net/article/136513.htm.
创建表数据

DROP TABLE IF EXISTS user;
CREATE TABLE user(ID INT PRIMARY KEY,
   username VARCHAR(255),
    password VARCHAR(255));
INSERT INTO user VALUES(1, 'lily','123');
INSERT INTO user VALUES(2, 'tom','456');

创建User类

package com.example.test.domain;

public class User {
    private Integer id;
    private String username;
    private String 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;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password=" + password + "]";
    }
}

在sources下创建UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"    
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

/<!-- 
		mapper接口的方法名称要和mapper映射文件的statement的id一致。
		mapper接口的方法参数类型要和mapper映射文件的statement的parameterType的值一致，而且它的参数是一个。
		mapper接口的方法返回值类型要和mapper映射文件的statement的resultType的值一致。
	 -->

<mapper namespace="com.example.test.mapper.UserMapper">
    <select id="queryUserList" resultMap="user">
        select * from user
    </select>
</mapper>

创建UserMapper接口

package com.example.test.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Mapper;

import com.example.test.domain.User;

@Mapper
public interface UserMapper {
    public List<User> queryUserList();

}

配置mybatis信息
找到mybatis配置文件
在application.yml中配置mybaties信息

#配置mybatis信息
#spring集成mybatis环境
#pojo别名扫描包
mybatis:
    type-aliases-package: com.example.test.domian 
    #加载mybatis映射文件
    #UserMapper.xml建在了mapper下
    mapper-locations: classpath:mapper/UserMapper.xml

在Controller中写入

@Controller
public class TestController {
    @Autowired
    UserMapper userMapper
    @RequestMapping("/test")
    @ResponseBody
    public List<User> queryUserList(){
        List<User> users = userMapper.queryUserList();
        return users;
    }

启动项目
报错：
org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): com.example.test.mapper.UserMapper.queryUserList
解决问题
是因为在写UserMapper.xml配置的时候，映射不到UserMapper，并且Mybtis依赖导入有问题
一定要检查好namespace和id和resultType对应的包名是否一致

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"    
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
//namespace必须是全包名
//resultType也必须到包名
<mapper namespace="com.example.test.mapper.UserMapper">
    <select id="queryUserList" resultType="com.example.test.domain.User">
        select * from user
    </select>
</mapper>

<!-- mybatis依赖 -->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.1.1</version>
		</dependency>

再启动：
在这里插入图片描述

resultType 和 resultMap的区别

原文章链接链接: https://www.cnblogs.com/coder-lzh/p/8960928.html.

resultType适用于单表查询。
resultType于SQL语句查询出的字段在相应的pojo中必须有和它相同的字段对应，比如说 cId和c_id 这种的都不能映射。
resultMap适用于单表查询和关联查询
resultMap配置一下，表和类的一一对应关系，所以说就算你的字段名和你的实体类的属性名不一样也没关系，都会给你映射出来。
resultMap的单表查询，当使用resultMap做SQL语句返回结果类型处理时，通常需要在mapper.xml中定义resultMap进行pojo和相应表字段的对应。

<!-- 订单查询关联用户的resultMap
    将整个查询的结果映射到cn.itcast.mybatis.po.Orders中
     -->
    <resultMap type="cn.itcast.mybatis.po.Orders" id="OrdersUserResultMap">
        <!-- 配置映射的订单信息 -->
        <!-- id：指定查询列中的唯 一标识，订单信息的中的唯 一标识，如果有多个列组成唯一标识，配置多个id
            column：订单信息的唯 一标识 列
            property：订单信息的唯 一标识 列所映射到Orders中哪个属性
          -->
        <id column="id" property="id"/>
        <result column="user_id" property="userId"/>
        <result column="number" property="number"/>
        <result column="createtime" property="createtime"/>
        <result column="note" property="note"/>        
    </resultMap>

关联查询（一对一），resultMap对于一对一表连接的处理方式通常为在主表的pojo中添加嵌套另一个表的pojo，然后在mapper.xml中采用association节点元素进行对另一个表的连接处理。

<!-- 订单查询关联用户的resultMap
    将整个查询的结果映射到cn.itcast.mybatis.po.Orders中
     -->
    <resultMap type="cn.itcast.mybatis.po.Orders" id="OrdersUserResultMap">
        <!-- 配置映射的订单信息 -->
        <!-- id：指定查询列中的唯 一标识，订单信息的中的唯 一标识，如果有多个列组成唯一标识，配置多个id
            column：订单信息的唯 一标识 列
            property：订单信息的唯 一标识 列所映射到Orders中哪个属性
          -->
        <id column="id" property="id"/>
        <result column="user_id" property="userId"/>
        <result column="number" property="number"/>
        <result column="createtime" property="createtime"/>
        <result column="note" property=note/>
        
        <!-- 配置映射的关联的用户信息 -->
        <!-- association：用于映射关联查询单个对象的信息
        property：要将关联查询的用户信息映射到Orders中哪个属性
         -->
        <association property="user"  javaType="cn.itcast.mybatis.po.User">
            <!-- id：关联查询用户的唯 一标识
            column：指定唯 一标识用户信息的列
            javaType：映射到user的哪个属性
             -->
            <id column="user_id" property="id"/>
            <result column="username" property="username"/>
            <result column="sex" property="sex"/>
            <result column="address" property="address"/>
        
        </association>
    </resultMap>

关联查询（一对多）：resultMap的处理方式为在订单表数据的pojo中添加一个list,list中为订单明细表的属性，在mapper.xml中采用如下的处理方式：

-- 订单及订单明细的resultMap
    使用extends继承，不用在中配置订单信息和用户信息的映射
     -->
    <resultMap type="cn.itcast.mybatis.po.Orders" id="OrdersAndOrderDetailResultMap" extends="OrdersUserResultMap">
        <!-- 订单信息 -->
        <!-- 用户信息 -->
        <!-- 使用extends继承，不用在中配置订单信息和用户信息的映射 -->
        
        
        <!-- 订单明细信息
        一个订单关联查询出了多条明细，要使用collection进行映射
        collection：对关联查询到多条记录映射到集合对象中
        property：将关联查询到多条记录映射到cn.itcast.mybatis.po.Orders哪个属性
        ofType：指定映射到list集合属性中pojo的类型
         -->
         <collection property="orderdetails" ofType="cn.itcast.mybatis.po.Orderdetail">
             <!-- id：订单明细唯 一标识
             property:要将订单明细的唯 一标识 映射到cn.itcast.mybatis.po.Orderdetail的哪个属性
               -->
             <id column="orderdetail_id" property="id"/>
             <result column="items_id" property="itemsId"/>
             <result column="items_num" property="itemsNum"/>
             <result column="orders_id" property="ordersId"/>
         </collection>
        
    
    </resultMap>