Spring Boot学习笔记二

Spring Boot入门第二篇

第一天的详见：https://www.cnblogs.com/LBJLAKERS/p/12001253.html

同样是新建一个pring Initializer快速创建Spring Boot项目.
在resource的目录下新建两个application-dev.properties/application-pro.properties属性文件分别代表开发环境和生产环境。如图：

指定使用的属性配置文件

一：通过默认的application.properties指定。

可以在默认的application.properties的文件中激活某个文件：

#正式环境

#表示激活的是哪一个属性文件

spring.profiles.active=pro

在dev的属性文件可以配置端口为：
```
 #开发环境

 server.port=
```
在Pro的属性文件可以配置端口号为：
```
#生产环境

server.port=
```

　　使用以上的方式如果去运行程序的话，在控制台就会显示激活pro的属性文件，使用的pro的端口

二：如果没有application.properties的属性文件，那么可以通过配置的方式来配置。虚拟机参数；

如上图所示的VM options的配置即可。

三、使用命令行的方式激活使用的属性配置文件。

打包项目为jar包，在cmd的命令窗口切换到jar包的目录，使用命令：
```
java -jar spring-boot-config-0.0.-SNAPSHOT.jar --spring.profiles.active=dev；
```

yml支持的多文档模块方式。

　　使用（---）两个横线的方式将文档分割成三个文档的模式。使用这种方式可以激活dev模块的文档

 spring:

   profiles:

     active: dev

 ---

 server:

   port:

 spring:

   profiles: dev

 ---

 server:

   port:

 spring:

   profiles: pro

配置文件加载位置

　　springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文。

　　在项目中加载的顺序为：（优先级由高到底，高优先级的配置会覆盖低优先级的配置；SpringBoot会从这四个位置全部加载主配置文件；互补配置；）

　　le:./config/
　　–file:./
　　–classpath:/config/
　　–classpath:/

　　注意：一般将配置文件放在resources目录下，这样在打包的时候就直接会将配置文件一同打包，否则不能够将配置文件一起打包为jar。并且所有的配置都可以在命令行上进行指定，

　　　　　例如在cmd的命令窗口下：java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar

　　　　　如果非要将application.properties的配置文件放到非resources的目录下，在cmd的命令窗口可以这样指定：

java -jar spring-boot--config--0.0.-SNAPSHOT.jar  --spring.config.location=配置文件存放的位置  --配置文件中的配置

　　　　这样才能生效

　　　　参看文档：https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#boot-features-external-config

自动配置文件的原理：

SpringBoot启动的时候加载主配置类，开启了自动配置功能 @EnableAutoConfiguration
@EnableAutoConfiguration 作用：
- 利用EnableAutoConfigurationImportSelector给容器中导入一些组件？
- 可以查看selectImports()方法的内容；
- List configurations = getCandidateConfigurations(annotationMetadata, attributes);获取候选的配置
可以在在项目的External Libraries中下的spring.factories文件中查看配置。
例如找到其中以下的：
```
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
```

　　　解读配置文件

@Configuration //表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件

@EnableConfigurationProperties(HttpEncodingProperties.class) //启动指定类的

ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties绑定起来；并把

HttpEncodingProperties加入到ioc容器中

@ConditionalOnWebApplication //Spring底层@Conditional注解（Spring注解版），根据不同的条件，如果

满足指定的条件，整个配置类里面的配置就会生效； 判断当前应用是否是web应用，如果是，当前配置类生效

@ConditionalOnClass(CharacterEncodingFilter.class) //判断当前项目有没有这个类

CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器；

@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing =

true) //判断配置文件中是否存在某个配置 spring.http.encoding.enabled；如果不存在，判断也是成立的

//即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；

public class HttpEncodingAutoConfiguration {

      //他已经和SpringBoot的配置文件映射了

      private final HttpEncodingProperties properties;

      //只有一个有参构造器的情况下，参数的值就会从容器中拿

      public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {

         this.properties = properties;

      }

 @Bean //给容器中添加一个组件，这个组件的某些值需要从properties中获取

@ConditionalOnMissingBean(CharacterEncodingFilter.class) //判断容器没有这个组件？

public CharacterEncodingFilter characterEncodingFilter() {

       CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();

       filter.setEncoding(this.properties.getCharset().name());

       filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));

       filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));

       return filter;

}

Spring boot整合springMVC

学习链接：https://docs.spring.io/spring-boot/docs/2.0.2.RELEASE/reference/htmlsingle/#boot-features-spring-mvc

springMVC的自动解管理

中央转发器
控制器
视图解析器
静态资源访问
消息转换器
格式化
静态资源管理

中央转发器：

　　xml无需配置：

 <servlet>

     <servlet-name>chapter2</servlet-name>

     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

     <load-on-startup></load-on-startup>

 </servlet>

 <servlet-mapping>

     <servlet-name>chapter2</servlet-name>

     <url-pattern>/</url-pattern>

 </servlet-mapping>

　　中央转发器被springboot自动接管，不在需要我们在xml文件配置，而且现在的项目也不是web项目，也不存在xml的文件配置。

org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\

控制器：

　　控制器Controller在springboot的注解扫描范围内自动管理

视图解析器的管理：

　　Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.

　 ContentNegotiatingViewResolver：组合所有的视图解析器的；

　　使用以前的方式是需要在配置文件中添加配置，现在就不需要配置文件，以前的配置方式：

 <bean id="de" class="org.springframework.web.servlet.view.InternalResourceViewResolver">

     <property name="prefix" value="/WEB-INF/jsp/"></property>

     <property name="suffix" value="*.jsp"></property>

 </bean>

　　在源码：

public ContentNegotiatingViewResolver viewResolver(BeanFactory beanFactory) {

    ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver();

 resolver.setContentNegotiationManager((ContentNegotiationManager)beanFactory.getBean(ContentNegotiationManager.class));

    resolver.setOrder(-);

    return resolver;

}

　　当我们做文件上传的时候我们也会发现multipartResolver是自动被配置好的

　　例如在页面上

<form action="/upload" method="post" enctype="multipart/form-data">

    <input name="pic" type="file">

    <input type="submit">

</form>

　　Controller中

 @ResponseBody

 @RequestMapping("/upload")

 public String upload(@RequestParam("pic")MultipartFile file, HttpServletRequest request){

     String contentType = file.getContentType();

     String fileName = file.getOriginalFilename();

     /*System.out.println("fileName-->" + fileName);

     System.out.println("getContentType-->" + contentType);*/

     //String filePath = request.getSession().getServletContext().getRealPath("imgupload/");

     String filePath = "D:/imgup";

     try {

         this.uploadFile(file.getBytes(), filePath, fileName);

     } catch (Exception e) {

         // TODO: handle exception

     }

     return "success";

 }

 public static void uploadFile(byte[] file, String filePath, String fileName) throws Exception {

     File targetFile = new File(filePath);

     if(!targetFile.exists()){

         targetFile.mkdirs();

     }

     FileOutputStream out = new FileOutputStream(filePath+fileName);

     out.write(file);

     out.flush();

     out.close();

 }

　　其中上传的文件的大小可以通过配置文件的方式配置

　application.properties, 默认限制是10MB，我们可以任意修改

消息转换和格式化

　　Springboot自动配置了消息转换器

　　格式化转换器的自动注册

　　时间类型我们可以在这里修改

　　在配置文件中指定好时间的模式我们就可以输入了

springboot扩展springmvc

　　其实springboot并非是完全自动化的，很多跟业务相关的仍然需要我们自己扩展，springboot给我们提供了接口。

　　我们可以通过实现WebMvcConfigurer的接口来扩展。

 public interface WebMvcConfigurer {

     default void configurePathMatch(PathMatchConfigurer configurer) {

     }

     default void configureContentNegotiation(ContentNegotiationConfigurer configurer) {

     }

     default void configureAsyncSupport(AsyncSupportConfigurer configurer) {

     }

     default void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {

     }

     default void addFormatters(FormatterRegistry registry) {

     }

     default void addInterceptors(InterceptorRegistry registry) {

     }

     default void addResourceHandlers(ResourceHandlerRegistry registry) {

     }

     default void addCorsMappings(CorsRegistry registry) {

     }

     default void addViewControllers(ViewControllerRegistry registry) {

     }

     default void configureViewResolvers(ViewResolverRegistry registry) {

     }

     default void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {

     }

     default void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> handlers) {

     }

     default void configureMessageConverters(List<HttpMessageConverter<?>> converters) {

     }

     default void extendMessageConverters(List<HttpMessageConverter<?>> converters) {

     }

     default void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {

     }

     default void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {

     }

     @Nullable

     default Validator getValidator() {

         return null;

     }

     @Nullable

     default MessageCodesResolver getMessageCodesResolver() {

         return null;

     }

 }

　　例如在容器中住注册视图控制器：

　　需求：创建一个MyMVCCofnig实现WebMvcConfigurer接口，实现一下addViewControllers方法，我们完成通过/tx访问，转发到success.html的工作

 @Configuration

 public class MyMVCCofnig implements WebMvcConfigurer{

     @Override

     public void addViewControllers(ViewControllerRegistry registry) {

         registry.addViewController("/tx").setViewName("success");

     }

Springboot的数据层开发：

数据源自动管理：

　　引入jdbc的依赖和springboot的应用场景

 <dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-jdbc</artifactId>

 </dependency>

 <dependency>

    <groupId>org.apache.commons</groupId>

    <artifactId>commons-dbcp2</artifactId>

 </dependency>

 <dependency>

    <groupId>mysql</groupId>

    <artifactId>mysql-connector-java</artifactId>

    <scope>runtime</scope>

 </dependency>

　　使用yaml的方式配置，配置如下：

 spring:

   datasource:

     username: root

     password: root

     url: jdbc:mysql://localhost:3306/boot_demo

     driver-class-name: com.mysql.jdbc.Driver

     type: com.zaxxer.hikari.HikariDataSource

我们可以自己指定数据源配置，通过type来选取使用哪种数据源

# type: org.apache.commons.dbcp2.BasicDataSource

配置druid的数据源

　　引入druid的依赖

<dependency>

   <groupId>com.alibaba</groupId>

   <artifactId>druid</artifactId>

   <version>1.0.</version>

</dependency>

<dependency>

   <groupId>log4j</groupId>

   <artifactId>log4j</artifactId>

   <version>1.2.</version>

</dependency>

修改   spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

　　在application.yaml中加入

 spring:

   datasource:

     username: root

     password: root

     url: jdbc:mysql://localhost:3306/boot_demo

     driver-class-name: com.mysql.jdbc.Driver

     type: com.alibaba.druid.pool.DruidDataSource

     initialSize:

     minIdle:

     maxActive:

     maxWait:

     timeBetweenEvictionRunsMillis:

     minEvictableIdleTimeMillis:

     validationQuery: SELECT  FROM DUAL

     testWhileIdle: true

     testOnBorrow: false

     testOnReturn: false

     poolPreparedStatements: true

     filters: stat,wall,log4j

     maxPoolPreparedStatementPerConnectionSize:

     useGlobalDataSourceStat: true

     connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=

　　创建数据源注册类

@Configuration

public class DruidConfig {

    @ConfigurationProperties(prefix = "spring.datasource")

    @Bean

    public DataSource dataSource(){

        return new DruidDataSource();

    }

}

　　配置druid运行期监控

@Configuration

public class DruidConfig {

    @ConfigurationProperties(prefix = "spring.datasource")

    @Bean

    public DataSource dataSource(){

        return new DruidDataSource();

    }

    @Bean

    public ServletRegistrationBean statViewServlet(){

        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(),

                "/druid/*");

        Map<String,String> initParams = new HashMap<>();

        initParams.put("loginUsername","root");

        initParams.put("loginPassword","root");

        initParams.put("allow","");//默认就是允许所有访问

        initParams.put("deny","192.168.15.21");

        bean.setInitParameters(initParams);

        return bean;

    }

    //2、配置一个web监控的filter

    @Bean

    public FilterRegistrationBean webStatFilter(){

        FilterRegistrationBean bean;

        bean = new FilterRegistrationBean();

        bean.setFilter(new WebStatFilter());

        Map<String,String> initParams = new HashMap<>();

        initParams.put("exclusions","*.js,*.css,/druid/*");

        bean.setInitParameters(initParams);

        bean.setUrlPatterns(Arrays.asList("/*"));

        return bean;

    }

}

　　打开监控页面

　http://localhost:8080/druid

springboot整合jdbctemplate

　　　创建一个新的项目，同时引入开发的坐标依赖

     <dependencies>

         <dependency>

             <groupId>org.springframework.boot</groupId>

             <artifactId>spring-boot-starter-web</artifactId>

         </dependency>

         <dependency>

             <groupId>org.springframework.boot</groupId>

             <artifactId>spring-boot-starter-test</artifactId>

             <scope>test</scope>

             <exclusions>

                 <exclusion>

                     <groupId>org.junit.vintage</groupId>

                     <artifactId>junit-vintage-engine</artifactId>

                 </exclusion>

             </exclusions>

         </dependency>

         <dependency>

             <groupId>org.springframework.boot</groupId>

             <artifactId>spring-boot-starter-web</artifactId>

         </dependency>

         <dependency>

             <groupId>org.springframework.boot</groupId>

             <artifactId>spring-boot-starter-test</artifactId>

             <scope>test</scope>

         </dependency>

         <dependency>

             <groupId>org.springframework.boot</groupId>

             <artifactId>spring-boot-devtools</artifactId>

             <optional>true</optional>

         </dependency>

         <dependency>

             <groupId>org.springframework.boot</groupId>

             <artifactId>spring-boot-starter-thymeleaf</artifactId>

         </dependency>

         <dependency>

             <groupId>org.webjars</groupId>

             <artifactId>jquery</artifactId>

             <version>3.3.</version>

         </dependency>

         <dependency>

             <groupId>org.mybatis.spring.boot</groupId>

             <artifactId>mybatis-spring-boot-starter</artifactId>

             <version>1.3.</version>

         </dependency>

         <dependency>

             <groupId>com.alibaba</groupId>

             <artifactId>druid</artifactId>

             <version>1.0.</version>

         </dependency>

         <!-- https://mvnrepository.com/artifact/log4j/log4j -->

         <dependency>

             <groupId>log4j</groupId>

             <artifactId>log4j</artifactId>

             <version>1.2.</version>

         </dependency>

         <dependency>

             <groupId>mysql</groupId>

             <artifactId>mysql-connector-java</artifactId>

             <scope>runtime</scope>

         </dependency>

     </dependencies>

在resource的目录下新建一个application.yaml文件，存入你要链接的数据库可相应的配置

 spring:

   datasource:

     username: root

     password: zhanghao22333

     url: jdbc:mysql://localhost:3306/boot_demo（注意使用的数据库）

     driver-class-name: com.mysql.cj.jdbc.Driver

     type: com.alibaba.druid.pool.DruidDataSource

     initialSize:

     minIdle:

     maxActive:

     maxWait:

     timeBetweenEvictionRunsMillis:

     minEvictableIdleTimeMillis:

     validationQuery: SELECT  FROM DUAL

     testWhileIdle: true

     testOnBorrow: false

     testOnReturn: false

     poolPreparedStatements: true

     filters: stat,wall,log4j

     maxPoolPreparedStatementPerConnectionSize:

     useGlobalDataSourceStat: true

     connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=

   mvc:

     date-format: yyyy-MM-dd

　可以在Spring-boot-autoconfiguration下的spring：factory中的：

org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\

查看它的源码

@Configuration(

    proxyBeanMethods = false

)

@ConditionalOnClass({DataSource.class, JdbcTemplate.class})

@ConditionalOnSingleCandidate(DataSource.class)

@AutoConfigureAfter({DataSourceAutoConfiguration.class})

@EnableConfigurationProperties({JdbcProperties.class})

@Import({JdbcTemplateConfiguration.class, NamedParameterJdbcTemplateConfiguration.class})

public class JdbcTemplateAutoConfiguration {

    public JdbcTemplateAutoConfiguration() {

    }

}

解析：在注解 JdbcTemplateConfiguration.class进去可以看出对jdbcTemplate做的封装，并注意它的主注解@Bean存放到容器中

@ConditionalOnMissingBean({JdbcOperations.class})

class JdbcTemplateConfiguration {

    JdbcTemplateConfiguration() {

    }

    @Bean

    @Primary

    JdbcTemplate jdbcTemplate(DataSource dataSource, JdbcProperties properties) {

        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

        Template template = properties.getTemplate();

        jdbcTemplate.setFetchSize(template.getFetchSize());

        jdbcTemplate.setMaxRows(template.getMaxRows());

        if (template.getQueryTimeout() != null) {

            jdbcTemplate.setQueryTimeout((int)template.getQueryTimeout().getSeconds());

        }

        return jdbcTemplate;

    }

}

最后在测试使用jdbctemplate查询数据库的操作，在测试中编写

 package zh.stu.springboot.test;

 import org.junit.jupiter.api.Test;

 import org.junit.runner.RunWith;

 import org.springframework.beans.factory.annotation.Autowired;

 import org.springframework.boot.test.context.SpringBootTest;

 import org.springframework.jdbc.core.JdbcTemplate;

 import org.springframework.test.context.junit4.SpringRunner;

 import java.util.List;

 import java.util.Map;

 @RunWith(SpringRunner.class)

 @SpringBootTest

 class TestApplicationTests {

     @Autowired

     JdbcTemplate jdbcTemplate;

     @Test

    public void contextLoads() {

         System.out.println();

         List<Map<String, Object>> maps = jdbcTemplate.queryForList("select * from tx_person");

         System.out.println(maps);

     }

 }

最终在控制台输出数据库中的数据

[{pid=, username=张浩, password=, gender=, p_addr=杭州1, birth=--, pname=}, {pid=, username=jj, password=jj, gender=, p_addr=jj, birth=--, pname=jj}]

springboot整合mybatis

导入开发的坐标

 <dependency>

            <groupId>org.mybatis.spring.boot</groupId>

            <artifactId>mybatis-spring-boot-starter</artifactId>

            <version>1.3.</version>
 </dependency>

新建一个实体类，提供get和set的方法

package zh.stu.springboot.test.model;

import java.util.Date;

public class TxPerson {

    private int pid;

    private String username;

    private String password;

    private String pAddr;

    private String pname;

    private int gender;

    private Date birth;

    public int getPid() {

        return pid;

    }

    public void setPid(int pid) {

        this.pid = pid;

    }

    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 String getpAddr() {

        return pAddr;

    }

    public void setpAddr(String pAddr) {

        this.pAddr = pAddr;

    }

    public String getPname() {

        return pname;

    }

    public void setPname(String pname) {

        this.pname = pname;

    }

    public int getGender() {

        return gender;

    }

    public void setGender(int gender) {

        this.gender = gender;

    }

    public Date getBirth() {

        return birth;

    }

    public void setBirth(Date birth) {

        this.birth = birth;

    }

    @Override

    public String toString() {

        return "TxPerson{" +

                "pid=" + pid +

                ", username='" + username + '\'' +

                ", password='" + password + '\'' +

                ", pAddr='" + pAddr + '\'' +

                ", pname='" + pname + '\'' +

                ", gender=" + gender +

                ", birth=" + birth +

                '}';

    }

}

然后新建一个mapper接口

 package zh.stu.springboot.test.mapper;

 import org.apache.ibatis.annotations.Insert;

 import org.apache.ibatis.annotations.Mapper;

 import org.apache.ibatis.annotations.Options;

 import org.apache.ibatis.annotations.Select;

 import zh.stu.springboot.test.model.TxPerson;

 import java.util.List;

 /**

  * @Mapper:可以给mapper借口自动生成一个实现类，让Spring对mapper接口的bean进行管理，并且可以省略复杂的xml文件的配置

  */

 @Mapper

 public interface TxPersonMapper {

     @Select("select * from tx_person")

     public List<TxPerson> selectPersons();

     /**

      *     @Options(useGeneratedKeys = true, keyProperty = "pid")

      *     数据库表中的pid是自动增长的，使用@Opetions的注解

      * @param p

      */

     @Options(useGeneratedKeys = true, keyProperty = "pid")

     @Insert("insert into tx_person(pid, username ,password,pname, p_addr, gender, birth)" +

             "values(#{pid},#{username},#{password},#{pname},#{pAddr},#{gender},#{birth})")

     public void insert(TxPerson p);

 }

注意：我在数据库中表tx_person的表中的字段p_add的形式存在（中间有一个下划线），而我在生成实体类的时候是：pAddr的形式，所以要添加一个类，将字段更改为驼峰的形式

 package zh.stu.springboot.test;

 import org.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer;

 import org.springframework.context.annotation.Bean;

 import org.springframework.context.annotation.Configuration;

 /**

  * 将数据库中的字段下划线更改为大写的方式例如p_add>>pAdd

  */

 @Configuration

 public class MyBatisConfig {

     @Bean

     public ConfigurationCustomizer getCustomizer(){

         return new ConfigurationCustomizer() {

             @Override

             public void customize(org.apache.ibatis.session.Configuration configuration) {

                 configuration.setMapUnderscoreToCamelCase(true);

             }

         };

     }

 }

最后在测试中测试

注入mapper

    @Autowired

    TxPersonMapper txPersonMapper;

在方法中对Txperson对象操作

 // 查询

 List<TxPerson> txPeople = txPersonMapper.selectPersons();

         System.out.println(txPeople);

 //新增

         TxPerson txPerson=new TxPerson();

         txPerson.setBirth(new Date());

         txPerson.setGender();

         txPerson.setpAddr("洛杉矶");

         txPerson.setPassword("");

         txPerson.setPname("");

         txPerson.setUsername("");

         txPersonMapper.insert(txPerson);

巴特西

Spring Boot学习笔记二

springboot整合jdbctemplate

springboot整合mybatis

最新文章

热门文章