当前位置: 澳门新濠3559 > 编程 > 正文

springboot让我们更加简单快速的构建spring应用,本

时间:2019-10-06 23:56来源:编程
缘起 前段时间公司领导叫编写一两课关于 springboot 的基础知识培训课程,说实话,也是今年年初才开始接触了SpringBoot这个脚手架,使用了之后才发现打开了一个新世界。再之后也没有

缘起

前段时间公司领导叫编写一两课关于springboot的基础知识培训课程,说实话,也是今年年初才开始接触了SpringBoot这个脚手架,使用了之后才发现打开了一个新世界。再之后也没有一些系统的学习过springboot,刚好借着这次编写培训教程机会,以一个初学者的身份,希望能够对sproingboot进行一次完整的学习。也希望通过此系列教程,能够加深对springboot的理解,之后也会编写关于springcloud的系列教程。也希望,通过系列教程的编写,能提供自己的写作水平(题外话:只从大学毕业后,就没有正经的写过文章了,很是遗憾。)

前言:学习SpringBoot不应该直接就是开始使用SpringBoot,如果直接拿来用肯定会有很多人不是很明白特别刚开始入门的,当然官网上也有快速上手的教程但是官网上跨度有点大,在这片文章中为主要是从以前没使用SpringBoot之前我们怎么做的以及慢慢的引入SpringBoot,我希望通过自己的体会和认识来帮助更多朋友来学习SpringBoot

目录结构

  • SpringJavaConfig
    • @Configuration和基础的@Bean
    • @ComponentScan和测试
    • @Bean标签属性详解
    • @Import标签
    • XML和Annotation的混用
    • 其他常用标签(@PropertySource和@PropertySources,@Profile和@ActiveProfile)
  • 第一个HelloWorld
  • Springboot简介
  • Springboot基本使用
    • 应用构建
    • SpringApplication
    • 参数配置
  • 日志
    • 默认日志
    • 外部日志框架LogBack
  • Springboot开发WEB应用
    • 静态资源
    • Freemarker集成
    • 错误处理
    • mybatis集成
    • 事务处理
    • 文件上传

【SpringBoot2.0文章汇总目录,java多线程教程文章汇总 长期更新系列】请多多支持

intellij IDEA配置springboot的图文教程,intellijspringboot

IntelliJ IDEA 简介

IDEA 全称 IntelliJ IDEA,是java语言开发的集成环境,IntelliJ在业界被公认为最好的java开发工具之一,尤其在智能代码助手、代码自动提示、重构、J2EE支持、各类版本工具(git、svn、github等)、JUnit、CVS整合、代码分析、 创新的GUI设计等方面的功能可以说是超常的。IDEA是JetBrains公司的产品,这家公司总部位于捷克共和国的首都布拉格,开发人员以严谨著称的东欧程序员为主。它的旗舰版本还支持HTML,CSS,PHP,MySQL,Python等。免费版只支持Java等少数语言。

Spring Boot是由Pivotal团队提供的全新框架,其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置,从而使开发人员不再需要定义样板化的配置。通过这种方式,Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

使用spring boot有什么好处

其实就是简单、快速、方便!平时如果我们需要搭建一个spring web项目的时候需要怎么做呢?

1)配置web.xml,加载spring和spring mvc

2)配置数据库连接、配置spring事务

3)配置加载配置文件的读取,开启注解

4)配置日志文件

下面给大家介绍intellij IDEA配置springboot的步骤,具体流程如下所示:

1.创建一个springboot项目:

澳门新濠3559 1

2.创建项目的文件结构以及jdk的版本

澳门新濠3559 2

  1. 选择项目所需要的依赖

澳门新濠3559 3

澳门新濠3559 4

4、文件结构

澳门新濠3559 5

5、项目不使用application.properties文件 而使用更加简洁的application.yml文件:
将原有的resource文件夹下的application.properties文件删除,创建一个新的application.yml配置文件,
文件的内容如下:

server:
 port: 8080
spring:
  datasource:
    name: test
    url: jdbc:mysql://127.0.0.1:3306/depot
    username: root
    password: root
    # 使用druid数据源
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    filters: stat
    maxActive: 20
    initialSize: 1
    maxWait: 60000
    minIdle: 1
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: select 'x'
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    maxOpenPreparedStatements: 20
mybatis:
 mapper-locations: classpath:mapping/*.xml
 type-aliases-package: com.winter.model
#pagehelper分页插件
pagehelper:
  helperDialect: mysql
  reasonable: true
  supportMethodsArguments: true
  params: count=countSql

6、使用mybatis generator 自动生成代码

generatorConfig.xml配置文件内容如下:

<?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>
  <!-- 数据库驱动:选择你的本地硬盘上面的数据库驱动包-->
  <classPathEntry location="E:1记javajar文件mysql-connector-java-5.1.7-bin (1).jar"/>
  <context id="DB2Tables" targetRuntime="MyBatis3">
    <commentGenerator>
      <property name="suppressDate" value="true"/>
      <!-- 是否去除自动生成的注释 true:是 : false:否 -->
      <property name="suppressAllComments" value="true"/>
    </commentGenerator>
    <!--数据库链接URL,用户名、密码 -->
    <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://127.0.0.1/mytest" userId="root" password="123456">
    </jdbcConnection>
    <javaTypeResolver>
      <property name="forceBigDecimals" value="false"/>
    </javaTypeResolver>
    <!-- 生成模型的包名和位置-->
    <javaModelGenerator targetPackage="com.chen.model" targetProject="src/main/java">
      <property name="enableSubPackages" value="true"/>
      <property name="trimStrings" value="true"/>
    </javaModelGenerator>
    <!-- 生成映射文件的包名和位置-->
    <sqlMapGenerator targetPackage="mapping" targetProject="src/main/resources">
      <property name="enableSubPackages" value="true"/>
    </sqlMapGenerator>
    <!-- 生成DAO的包名和位置-->
    <javaClientGenerator type="XMLMAPPER" targetPackage="com.chen.mapper" targetProject="src/main/java">
      <property name="enableSubPackages" value="true"/>
    </javaClientGenerator>
    <!-- 要生成的表 tableName是数据库中的表名或视图名 domainObjectName是实体类名-->
    <table tableName="t_user" domainObjectName="User" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"></table>
  </context>
</generatorConfiguration>

澳门新濠3559 6

点击

澳门新濠3559 7

SpringBoot项目在IntelliJ IDEA中实现热部署

spring-boot-devtools是一个为开发者服务的一个模块,其中最重要的功能就是自动应用代码更改到最新的App上面去。

原理是在发现代码有更改之后,重新启动应用,但是速度比手动停止后再启动更快。

其深层原理是使用了两个ClassLoader,一个Classloader加载那些不会改变的类(第三方Jar包),另一个ClassLoader加载会更改的类,称为restart ClassLoader

,这样在有代码更改的时候,原来的restart ClassLoader被丢弃,重新创建一个restart ClassLoader,由于需要加载的类相比较少,所以实现了较快的重启时间。

即devtools会监听classpath下的文件变动,并且会立即重启应用(发生在保存时机)

一、开启idea自动make功能

1、CTRL SHIFT A --> 查找make project automatically --> 选中

澳门新濠3559 8

2、CTRL SHIFT A --> 查找Registry --> 找到并勾选compiler.automake.allow.when.app.running

澳门新濠3559 9

最后重启idea

一、使用spring-boot-1.3开始有的热部署功能

1、加maven依赖

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

2、开启热部署

<build>
  <plugins>
    <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
      <configuration>
        <fork>true</fork>//该配置必须
      </configuration>
    </plugin>
  </plugins>
</build>

总结

以上所述是小编给大家介绍的intellij IDEA配置springboot的图文教程,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对帮客之家网站的支持!

IDEA配置springboot的图文教程,intellijspringboot IntelliJ IDEA 简介 IDEA 全称 IntelliJ IDEA,是java语言开发的集成环境,IntelliJ在业界被公认为最...

开发环境说明

在开发IDE选择上,选择了spring官方退出的sts版本,本人未使用过intellij idea(可能落伍了,⊙﹏⊙‖∣)。

  • java 8
  • spring boot: 1.5.14.RELEASE
  • 开发IDE:Spring Tool Suite(3.9.3.RELEASE)
  • maven: 3.0.3

(在这里我们先以最原始的方式来创建项目和测试)创建一个Maven项目添加依赖和加入配置文件application.xml``SomeBean.java

【SpringBoot2.0系列01】初识SpringBoot【SpringBoot2.0系列02】SpringBoot之使用Thymeleaf视图模板【SpringBoot2.0系列03】SpringBoot之使用freemark视图模板【SpringBoot2.0系列04】SpringBoot之使用JPA完成简单的rest api【SpringBoot2.0系列05】SpringBoot之整合Mybatis【SpringBoot2.0系列06】SpringBoot之多数据源动态切换数据源【SpringBoot2.0系列07】SpringBoot之redis使用(Lettuce版本)

教程安排

由于自身能力有限,本着简单入门的原则,并结合了工作中碰见的一些常见场景和问题,将工作中常用知识点进行编写,同时也会穿插一些能提供开发效率的第三方包或者工具的介绍和简单实例。

  • 第一章:第一个Springboot应用
  • 第二章:lombok介绍及简单使用
  • 第三章:springboot配置详解
  • 第四章:日志配置
  • 第五章:多环境配置
  • 第六章:常用注解介绍及简单使用
  • 第七章:过滤器、监听器、拦截器
  • 第八章:统一异常处理
  • 第九章:Mybatis-plus的集成和使用
  • 第十章:Swagger2集成
  • 第十一章:Redis的集成和使用
  • 第十二章:RabbitMQ的集成和使用
  • 第十三章:测试相关(单元测试、性能测试)
  • 第十四章:基于docker的简单部署
  • 第十五章:基于Postman的RESTful接口测试
  • 第十六章:web应用开发
  • 第十七章:web应用开发之文件上传
  • 第十八章:web应用开发之WebJars使用
  • 第十九章:web应用开发之WebSocket
  • 第二十章:异步开发之异步请求
  • 第二十一章:异步开发之异步调用
  • 第二十二章:定时任务
  • 第二十三章:日志管理之整合篇
  • 第二十四章:日志管理之AOP统一日志
  • 待补充......

springboot让我们更加简单快速的构建spring应用,本文地址。番外:

  • SpringBoot | 番外:使用小技巧合集
  • Mybatis-Plus使用全解
public class SomeBean {}

想必大家都一定用过spring框架,每次整合spring框架的时候总是会有无穷无尽的xml配置文件,第一次写配置文件的时候,大家还会抱着学习的心态认真读每一个配置,但是当我们每次在构建项目都要写同样的配置文件大家应该会觉得厌烦,尽管只是复制粘贴。那么现在你就不用担心了,使用springboot让你更简单的构建spring应用。

老生常谈

  • 个人QQ:499452441
  • 公众号:lqdevOps

澳门新濠3559 10image

个人博客:

本文地址:

application.xml

springboot让我们更加简单快速的构建spring应用,并且内置web容器(tomcat、jetty等)支持jar包的方式启动一个web应用。

 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <bean ></bean> </beans>
    1. 为所有Spring开发者更快的入门
    1. 开箱即用,提供各种默认配置来简化项目配置
    1. 内嵌式容器简化Web项目
    1. 没有冗余代码生成和XML配置的要求

这个是基于XML配置的方式MyTest.java

本节主要目标是通过构建一个简单的SpringBoot项目,实现一个hello word接口。通过这样一个简单的例子让我们对springboot有一个了解。

 public class MyTest { @Test public void test1(){ ApplicationContext ctx=new ClassPathXmlApplicationContext("application.xml"); SomeBean sb = ctx.getBean(SomeBean.class); System.out.println; }}
  • java8 及以上
  • SpringBoot 2.0.4

上面是我们最简单的一个Spring Demo

3.2.1 spring官网 SPRING INITIALIZR

1、访问 http://start.spring.io/

2、选择maven构建、使用java语法、并且SpringBoot版本为2.0.4

具体如图:

澳门新濠3559 11image.png

3、点击Generate Project 下载构建成功的项目压缩包

解压完成之后我们就可以通过IntelliJ IDEA开发工具导入到工程,

    1. 菜单中选择File–>New–>Project from Existing Sources...
    1. 选择解压后的项目文件夹,点击OK
    1. 点击Import project from external model并选择Maven,点击Next到底为止。
    1. 如果你的环境有多个版本的JDK,注意到选择Java SDK的时候请选择系统安装1.8版本

下面通过标签来配置SpringOtherBean.java

3.2.2 使用idea构建

1、打开idea选择new -> project -> SPRING INITIALIZR

澳门新濠3559 12idea构建

2、在ProjectSDK选择jdk83、点击next 输入gourpId artifactId 然后继续next 一直到完成就可以

澳门新濠3559 13image.png

澳门新濠3559,其实大家看的出来,两种方式都是一样的,只不过用idea省去了我们手动下载介绍并且导入的步骤,稍显方便。

public class OtherBean {}

3.2.3、项目结构

澳门新濠3559 14image.png

关键目录解释

  • 1、/src/main/java/ 存放项目所有源代码目录
  • 2、/src/main/resources/ 存放项目所有资源文件以及配置文件目录
  • 3、/src/test/ 存放测试代码目录

其中生成的Chapter1Application和Chapter1ApplicationTests类都可以直接运行来启动当前创建的项目。

打开pom.xml 添加spring-boot-starter-web 即可

<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</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-starter-web</artifactId> </dependency> </dependencies>

src/main/java目录下的chapter1包下新建一个HelloWorldController.java文件

@RestController@RequestMappingpublic class HelloWorldController { @GetMapping public String hello() { return "hello world"; }}

其中

  • @RequestController是一个复合注解 ,大家按住ctrl看源码会发现 @RequestController = @Controller @ResponseBody 那么它的作用就不言而喻了,代表当前类是一个控制器并且返回所有的方法将会返回json数据

双击打开Chapter1Application文件启动。

澳门新濠3559 15image.png

从图中可以看出日志打印启动tomcat服务的端口是8080 ,代表启动成功。

打开浏览器访问http://localhost:8080/hello

澳门新濠3559 16image.png

那么有时候我们的8080端口被占用了,那么就会启动失败,提示端口被占用,如何改变springboot启动的默认端口呢?

打开application.yml 这时候大家就会问了 不是application.properties吗 其实yml文件也是配置文件的一种,它的书写简洁,我比较喜欢。

yml写法

server: port: 9090

properties写法

server.port=9090

上面的代码就是设置web服务启动的端口了。

通过这次学习,我们了解了springboot如何启动一个web服务,并且如何更改web服务启动的默认端口。

最后配套教程的代码全部在这里github

澳门新濠3559 17公众号

下面我们写了一个方法返回一个SomeBean的对象我们要告诉Spring这个方法是Spring帮我们管理的bean通过@Bean标签

AppConfig .java

 // 作为Spring的主配置文件 //@Configuration标签表示这个类可被Spring识别的配置对象的类,只有有这个标记的标签的类才能使用@Bean标签作用于对应的方法上面 @Configuration public class AppConfig { //@Bean标签表示让Spring帮我们管理bean @Bean public SomeBean someBean(){ return new SomeBean(); } @Bean public OtherBean otherBean(){ return new OtherBean(); } }

不像上一个demo,这个是基于AnnotationConfigApplicationContext来配置的MyTest.java

@Testpublic void test() { ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class); SomeBean sb = ctx.getBean(SomeBean.class); OtherBean ob = ctx.getBean(OtherBean.class); System.out.println; System.out.println;}

到这里我们就已经学完了两个重要的标签 @Configuration和@Bean,@Configuration标签表示这个类可被Spring识别的配置对象的类,只有有这个标记的标签的类才能使用@Bean标签作用于对应的方法上面@Bean(destroyMethod = "destory", initMethod = "init")也可以通过这样的写法来配置bean的初始化方法和销毁方法

@Component标签
@Componentpublic class SomeBean {}

@Componentpublic class OtherBean {}

//@Configuration标签表示这个类可被Spring识别的配置对象的类,这有有这个标记的标签的类才能使用@Bean标签作用于对应的方法上面// @ComponentScan:开启组件自动扫描;默认情况下,它会扫描当前类所在的包及其子包中的所有标签对象加载到Spring容器@Configuration@ComponentScan(basePackages="com.jd.scan")public class AppConfig {}

public class MyTest {@Testpublic void test() { ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class); SomeBean sb = ctx.getBean(SomeBean.class); OtherBean ob = ctx.getBean(OtherBean.class); System.out.println; System.out.println;}}

@ComponentScan:开启组件自动扫描;默认情况下,它会扫描当前类所在的包及其子包中的所有标签对象加载到Spring容器

对象的关系引用

在someBean里依赖一个otherBean

@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes = AppConfig.class)public class MyTest {@Autowired@Qualifier("somebean")private SomeBean somebean; //@Autowired //@Qualifier("somebean2") //private SomeBean somebean2;@Testpublic void test() { System.out.println(somebean.getOtherBean; //System.out.println(somebean2.getOtherBean;}}

 @Configuration public class AppConfig {//第一种方式@Bean(destroyMethod = "destory", initMethod = "init")public SomeBean somebean(OtherBean otherbean) { SomeBean sBean = new SomeBean(); sBean.setOtherBean(otherbean); return sBean; }//第二种方式 // @Bean // public SomeBean somebean2() { // SomeBean sBean = new SomeBean(); // sBean.setOtherBean(otherbean; // return sBean; // }@Beanpublic OtherBean otherbean() { return new OtherBean();}}

使用try来关闭容器

@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes=AppConfig.class)public class MyTest2 {@Testpublic void test() { try (AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class)) { SomeBean sb = context.getBean(SomeBean.class, "somebean"); System.out.println; }}}
@import标签
public class MyDataSource {}

public class MyRedisTemplate {}

@Configurationpublic class ConfigRedis {@Beanpublic MyRedisTemplate myRedisTemplate(){ return new MyRedisTemplate();}}

@Configurationpublic class ConfigDataSource {@Beanpublic MyDataSource myDatasource(){return new MyDataSource(); }}

AppConfig这个类因为打上@Configuration标签所以是主配置文件,他需要连接着两个类ConfigDataSource.class,ConfigRedis.class 只需要使用@Import 标签就可以表示导入类

@Configuration@Import({ConfigDataSource.class,ConfigRedis.class})public class AppConfig {}

@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes = AppConfig.class)public class MyTest {@Autowiredprivate MyDataSource datasource;@Autowiredprivate MyRedisTemplate redisTemplate;@Testpublic void test(){ System.out.println(datasource); System.out.println(redisTemplate);}}
@importresource标签 在javaconfig中混用xml

OtherBean.java

public class OtherBean {}

application.xml

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"xmlns:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop" xmlns:jee="http://www.springframework.org/schema/jee"xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"><bean /> </beans>

SomeBean.java

@Setter@Getterpublic class SomeBean {private OtherBean otherBean;public void init() { System.out.println("===init====");}public void destory() { System.out.println("====destory=====");}}

AppConfig.java

@Configuration// @importresource标签来在javaconfig中混用xml config@ImportResource("classpath:com/jd/importresource/application.xml")public class AppConfig {@Bean(destroyMethod = "destory", initMethod = "init")public SomeBean somebean(OtherBean otherbean) { SomeBean sBean = new SomeBean(); sBean.setOtherBean(otherbean); return sBean;}}

MyTest.java

@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes = AppConfig.class) public class MyTest {@Autowiredprivate SomeBean somebean;@Testpublic void test() { System.out.println(somebean.getOtherBean;}}

@ImportResource("classpath:com/jd/importresource/application.xml") 通过使用@ImportResource标签来导入资源

引入外部的.properties资源文件

db.properties

db.username=usernamedb.password=passworddb.url=urldb.driverClass=driverClass

MyDatasource .java

@Setter@Getter@ToString@AllArgsConstructorpublic class MyDatasource {private String username;private String password;private String url;private String driverClass;}

AppConfig .java

@Configuration // @PropertySource代表引入外部的.properties资源文件 //@PropertySources嵌套@PropertySource引入多个外部资源文件@PropertySource("classpath:com/jd/properties/db.properties")public class AppConfig {@Value("${db.username}")private String username;@Value("${db.password}")private String password;@Value("${db.url}")private String url;@Value("${db.driverClass}")private String driverClass;@Beanpublic static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer (){ return new PropertySourcesPlaceholderConfigurer();}@Beanpublic MyDatasource datasource(){ return new MyDatasource(username, password, url, driverClass);}}

MyTest .java

@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes = AppConfig.class)public class MyTest {@Autowiredprivate MyDatasource datasource;@Testpublic void test() { System.out.println(datasource);}}

@Configuration // @PropertySource代表引入外部的.properties资源文件 //@PropertySources嵌套@PropertySource引入多个外部资源文件@PropertySource("classpath:com/jd/properties/db.properties")public class AppConfig { //Environment代表spring的环境,在环境里面只有两种东西: 1,读入的外部资源文件(properties); 2,profile @Autowiredprivate Environment env;@Beanpublic MyDatasource datasource() { return new MyDatasource(env.getProperty("db.username"), env.getProperty("db.password"), env.getProperty, env.getProperty("db.driverClass"));}}
profile

db-dev.properties db-profile.properties

db.username=usernamedb.password=passworddb.url=urldb.driverClass=driverClass 

MyDatasource.java

@Setter@Getter@ToString@AllArgsConstructorpublic class MyDatasource {private String username;private String password;private String url;private String driverClass;}

//生产环境的配置对象@Configuration@Profile@PropertySource("classpath:com/jd/profile/db-pro.properties")public class ConfigPro {@Value("${db.username}")private String username;@Value("${db.password}")private String password;@Value("${db.url}")private String url;@Value("${db.driverClass}")private String driverClass;@Beanpublic MyDatasource datasource() { return new MyDatasource(username, password, url, driverClass);}}

//针对开发环境的配置@Configuration@Profile@PropertySource("classpath:com/jd/profile/db-dev.properties")public class ConfigDev {@Value("${db.username}")private String username;@Value("${db.password}")private String password;@Value("${db.url}")private String url;@Value("${db.driverClass}")private String driverClass;@Beanpublic MyDatasource datasource() { return new MyDatasource(username, password, url, driverClass);}}

AppConfig .java

@Configuration@Import({ ConfigDev.class, ConfigPro.class })public class AppConfig {@Beanpublic static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() { return new PropertySourcesPlaceholderConfigurer();}}

MyTest.java

@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(classes = AppConfig.class)@ActiveProfilespublic class MyTest {@Autowiredprivate MyDatasource datasource;@Testpublic void test() { System.out.println(datasource);}}

到这里我们把需要回顾和拓展的知识都有一定加深下面我们开始正式学习SpringBoot

先演示在地址栏访问loclhost:8080/hello返回字符串hello world

1.在pom.xml文件中加入依赖
 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.6.RELEASE</version></parent><dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency></dependencies>
2.创建一个Controller:

HelloSpringBoot.java

@SpringBootApplication@Controllerpublic class HelloSpringBoot {@RequestMapping@ResponseBodypublic String hello() { return "hello world";}public static void main(String[] args) { SpringApplication.run(HelloSpringBoot.class, args);}}

澳门新濠3559 18Snip20170910_30.png

3.运行 main方法

. ____ _ __ _ _/ / ' __ _ __ __ _ __ | '_ | '| | ' / ` | / *)| |)| | | | | || (| | ) ) ) )' |____| .|| ||| |_, | / / / /=========||==============|*/=////:: Spring Boot :: (v1.5.6.RELEASE)

澳门新濠3559 19

分析:1,继承spring-boot-starter-parent,引入基本的依赖管理配置;2,引入spring-boot-starter-web,自动引入了springweb相关的包;3,@SpringBootApplication:这个注解告诉springboot自动的去完成相关配置,包括基础类的加载,bean的扫描等等,这个后面详细介绍;简单理解为这个标签为我们的应用配置完成了很多基本功能;4,SpringApplication.run:这个是springboot为我们提供的最大的区别,在于springboot不再是一个web应用,需要我们自己去打包,部署,启动tomcat,springboot默认把tomcat打包到应用中,我们可以以正常的运行jar的方式来运行springboot应用;

应用独立运行:1,pom文件中添加:

<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins></build>

2,使用package命令打包,在命令行中使用java -jar xx.jar运行;注意,一定要引入spring-boot-maven-plugin之后运行package打包才能正常运行;

澳门新濠3559 20

3,直接使用maven插件:spring-boot:run运行;

Springboot的优缺点1. 创建独立的Spring应用程序2. 嵌入的Tomcat,无需部署WAR文件3. 简化Maven配置4. 自动配置Spring5. 提供生产就绪型功能,如日志,健康检查和外部配置6. XML没有要求配置7. 非常容易和第三方框架集成起来;缺点:1,版本更新较快,可能出现较大变化;2,因为约定大于配置,所以经常会出现一些很难解决的问题;

1,Springboot应用的基本结构:通过start.spring.io创建一个springboot应用:2,spring-boot-starter-parent简介:1,包含了常用版本属性;要修改java编译版本,可以修改: <properties> <java.version>1.7</java.version> </properties>2,包含了常用的dependenceManagement;3,Springboot非常优秀的地方在于提供了非常多以spring-boot-starter-开头的开箱即用的工具包,常见工具包有以下一些:spring-boot-starter:核心的工具包,提供了自动配置的支持,日志和YAML配置支持;spring-boot-starter-activemq:针对快速集成ActiveMQ的工具包;spring-boot-starter-aop:提供了快速集成SpringAOP和AspectJ的工具包;spring-boot-starter-data-redis:提供了快速集成Redis和Jedis的工具包;spring-boot-starter-freemarker:提供了快速集成Freemarker的工具包;spring-boot-starter-mail:提供了快速集成邮件发送的工具包;spring-boot-starter-test:提供了对Springboot应用的测试工具包;spring-boot-starter-web:提供了对web开发的工具包,包括基于SpringMVC的RESTful应用开发,内置的tomcat服务器等;spring-boot-starter-actuator:提供了对生产环境中应用监控的工具包;spring-boot-starter-logging:提供了对日志的工具包,默认使用Logback;3,Springboot应用的热部署:除了使用JRebel来实现热部署,还可以使用Springboot提供的spring-boot-devtools包来完成Springboot应用热部署;<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId><optional>true</optional></dependency>1)原理:SpringBoot重启是reload重启,通过监控classpath的变化,如果classpath中的文件发生变化,即触发重启。springboot通过两个classpath来完成reload,一个basic classloader中加载不变的类,一个restart classloader中加载classpath中的类,重启的时候,restart classloader中的类丢弃并重新加载;2)排除资源:spring.devtools.restart.exclude=static/,templates/*spring.devtools.restart.additional-exclude=public/** (处理默认配置排除之外的)spring.devtools.restart.enabled=false

@SpringBootApplication简介:@SpringBootApplication由三个主要的标签构成:@SpringBootConfiguration,@EnableAutoConfiguration,@ComponentScan1)@SpringBootConfiguration:本质就是一个@Configuration,代表这是spring容器的主配置类;2)@EnableAutoConfiguration:开启自动配置,Springboot使用这个标签自动的把内置的符合条件的@Configuration类加载进入应用;可以查看spring-boot-autoconfigure包中的META-INF/spring.factories文件中的配置项(原理,由@EnableAutoConfiguration标签引入的AutoConfigurationImportSelector类中,使用Spring的SpringFactoriesLoader类实现加载)3)@ComponentScan:自动扫描;

SpringApplication简介:1,SpringApplication类提供了一个标准化的应用执行流程,并在这个执行流程中为我们提供了一些应用扩展点;但大部分情况下,我们只需要使用它就可以了;2,SpringBoot提供了一些扩展点,比如修改Banner:1)创建一个banner.txt2)设置banner,在配置文件中使用spring.main.banner-mode=off3,可以通过创建对象的方式来运行SpringApplication

澳门新濠3559 21

 2)通过builder完成:

澳门新濠3559 22

4,参数的处理:在应用启动过程中,可以通过启动参数给应用传递一些额外的参数来控制应用的运行;1,在main方法中可以直接使用传入的参数;2,可以任何类中直接通过@Autowired注入一个ApplicationArguments对象;

澳门新濠3559 23

Springboot中的日志

为什么要用日志?1.比起System.out.println,日志框架可以把日志的输出和代码分离;2.日志框架可以方便的定义日志的输出环境,控制台,文件,数据库;3.日志框架可以方便的定义日志的输出格式和输出级别;

Springboot的默认日志使用:1.Springboot默认已经开启日志;默认的日志格式为:时间 日志级别 PID 线程名称 日志类 日志说明2.Springboot的日志区别系统日志和应用日志;3.Springboot推荐使用Logback作为日志框架(common-logging,java-logging,log4j,logback,slf4j)

Logback使用方法(推荐使用logback自己的配置文件)1.springboot默认支持logback.xml或者logback-spring.xml,推荐使用logback-spring.xml,springboot会增加额外功能;2.可以通过logging.config=classpath:mylogback.xml指定自己的logback配置文件;3.一个典型的logback配置文件:

澳门新濠3559 24

Logback使用介绍:1,<configuration>:Logback配置根元素属性包括:1,scan: 当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。2,scanPeriod: 设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。当scan为true时,此属性生效。默认的时间间隔为1分钟。3,debug: 当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。子元素:<contextName>:上下文名字;<property>:定义属性,可以使用${}在配置文件中使用;

2,<appender>:在logback中是用于具体记录日志的组件,可以用来配置日志记录方式,日志记录格式等;属性包括:name:appender的名字,用于下面在配置日志的时候指定;class:使用到的appender类;

常见的appender:1,ch.qos.logback.core.ConsoleAppender:输出到控制台;2,ch.qos.logback.core.FileAppender:输出到文件;3,ch.qos.logback.core.rolling.RollingFileAppender:输出到文件,可以配置滚动策略,当日志达到某个条件之后分文件记录;4,还有其他的appender,比如写到数据库等;

<appender>元素的基本格式:<appender name="" ><encoder><pattern>...</pattern></encoder><otherconfig></otherconfig></appender>

<encoder>元素用来规定日志的输出格式,所有表达式都以%开始表示接下来是一个特殊标识符常见标识符:1,%logger{n}:输出Logger对象类名,n代表长度;2,%class{n}:输出所在类名,3,d{pattern}或者date{pattern}:输出日志日期,格式同java;4,L/line:日志所在行号;5,m/msg:日志内容;6,method:所在方法名称;7,p/level:日志级别;8,thread:所在线程名称;

常见的appender使用:1)ConsoleAppender输出到控制台,子元素:<encoder>:日志格式化<target>:System.out或者System.err

澳门新濠3559 25图片.png

2)FileAppender输出到文件,子元素:file:被写入的文件名,可以是相对目录,也可以是绝对目录,如果上级目录不存在会自动创建,没有默认值。append:文件结尾,如果是 false,清空现存文件,默认是true。encoder:对日志进行格式化

澳门新濠3559 26图片.png

3)RollingFileAppender输出到文件,可以设置文件滚动条件,子元素:append:如果是 true,日志被追加到文件结尾,如果是 false,清空现存文件,默认是true。rollingPolicy:滚动策略,涉及文件移动和重命名。常用滚动策略:ch.qos.logback.core.rolling.TimeBasedRollingPolicy:按照时间控制来控制记录文件;fileNamePattern:文件名称格式,以%d{pattern};maxHistory:可选节点,控制保留的归档文件的最大数量,超出数量就删除旧文件。(以文件最小时间为准)

澳门新濠3559 27图片.png

SizeAndTimeBasedRollingPolicy:按照时间和大小控制记录文件;fileNamePattern:文件名称格式,可以使用%i来控制索引编号;maxFileSize:这是活动文件的大小,默认值是10MBmaxHistory:可选节点,控制保留的归档文件的最大数量,超出数量就删除旧文件。(以文件最小时间为准)

澳门新濠3559 28

下面我们来通过一个小Demo来说明application.properties

db.username=usernamedb.password=passworddb.url=urlspringboot.randomlong=${random.long[1,100]}

MyDatasource.java

@Setter@Getterpublic class MyDatasource {private String username;private String password;private String url;}

HelloController.java

@Controllerpublic class HelloController {private static final Logger logger = LoggerFactory.getLogger(HelloController.class);@Autowiredprivate MyDatasource datasource;@RequestMapping@ResponseBodypublic String hello() { //error<warn<info<debug<trace logger.info; if (logger.isDebugEnabled { logger.debug("准备转出10000"); } if (logger.isTraceEnabled { logger.trace; logger.trace("查询账户余额为12000"); } if (logger.isDebugEnabled { logger.debug("检查转出账户..."); logger.debug; logger.debug("执行转出10000"); logger.debug; } logger.info; System.out.println(datasource); return "hello world";}}

App.java

@SpringBootApplicationpublic class App {@Bean@ConfigurationProperties(prefix = "db")public MyDatasource datasource() { return new MyDatasource();}public static void main(String[] args) { new SpringApplicationBuilder(App.class).bannerMode.build().run;}

}

logback日志的xml配置文件

logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?><configuration><appender name="CONSOLE" > <encoder> <pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n</pattern> </encoder> <target>System.out</target></appender><appender name="FILE" > <encoder> <pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n</pattern> </encoder> <file>springbootdemo.log</file> <append>true</append></appender><appender name="ROLLFILE" > <encoder> <pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n</pattern> </encoder> <append>true</append> <rollingPolicy > <fileNamePattern>springboot.%d{yyyy-MM-dd}.log</fileNamePattern> <maxHistory>30</maxHistory> </rollingPolicy></appender><appender name="SIZEROLLFILE" > <encoder> <pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n</pattern> </encoder> <append>true</append> <rollingPolicy > <fileNamePattern>springboot.%d{yyyy-MM-dd}.%i.log</fileNamePattern> <maxFileSize>10MB</maxFileSize> <maxHistory>30</maxHistory> </rollingPolicy></appender><root level="DEBUG"> <appender-ref ref="CONSOLE" /> <appender-ref ref="SIZEROLLFILE" /></root></configuration>
Springmvc和freemarker的集成

添加依赖引入spring-boot-starter-freemarker;

 <dependency> <groupId>org.freemarker</groupId> <artifactId>freemarker</artifactId> <version>2.3.23</version> </dependency>

web.xml

<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"><display-name>freemarker</display-name> <!-- SpringMVC前端控制器 --> <servlet><servlet-name>springMVC</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:application-web.xml</param-value></init-param><load-on-startup>1</load-on-startup> </servlet> <servlet-mapping><servlet-name>springMVC</servlet-name><url-pattern>*.do</url-pattern></servlet-mapping> <!-- 编码过滤器 --> <filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param> <param-name>encoding</param-name> <param-value>utf-8</param-value></init-param> </filter> <filter-mapping><filter-name>encodingFilter</filter-name><url-pattern>/*</url-pattern> </filter-mapping> <welcome-file-list><welcome-file>index.do</welcome-file> </welcome-file-list></web-app>

application.xml

<!--开启注解扫描 --><context:component-scan base-package="com.jd" />

application-web.xml

<import resource="classpath:application.xml" /><!-- 支持springmvc的注解驱动 --><mvc:annotation-driven /><!-- 配置一个freemarker的配置对象 --><bean> <!-- 配置freemarker的文件编码 --> <property name="defaultEncoding" value="UTF-8" /> <!-- 配置freemarker寻找模板的路径 --> <property name="templateLoaderPath" value="/WEB-INF/views/" /></bean><!-- 配置一个针对于freemarker的viewresovler --><bean > <!-- 配置逻辑视图自动添加的后缀名 --> <property name="suffix" value=".ftl" /> <!-- 配置视图的输出HTML的contentType --> <property name="contentType" value="text/html;charset=UTF-8" /></bean>

FreemarkerController.java

@Controllerpublic class FreemarkerController {@RequestMappingpublic String hello(Model model){ model.addAttribute("msg","hello 我是 freemarker"); return "hello";}}
Springboot和freemarker的集成

添加依赖

<properties> <java.version>1.8</java.version></properties><parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.6.RELEASE</version></parent><dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-freemarker</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> </dependency></dependencies><build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins></build>

创建模板

澳门新濠3559 29Snip20170910_27.png

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>Insert title here</title></head><body><h1>${msg}</h1></body></html>

FreemarkerController.java

@Controllerpublic class FreemarkerController {@RequestMappingpublic String hello(Model model){ model.addAttribute("msg","hello 我是 freemarker"); return "hello";}}

App.java

//运行main@SpringBootApplicationpublic class App {public static void main(String[] args) { SpringApplication.run(App.class, args);}}

访问网页

澳门新濠3559 30

Springboot对freemarker的配置:1,spring.freemarker.enabled=true:是否开启freemarker支持;2,spring.freemarker.allow-request-override:是否允许request中的属性覆盖model中同名属性;默认false;3,spring.freemarker.allow-session-override:是否允许session中的属性覆盖model中同名属性;默认false;4,spring.freemarker.cache:是否支持模板缓存;默认false;5,spring.freemarker.charset=UTF-8:模板编码6,spring.freemarker.content-type=text/html:模板contenttype;7,spring.freemarker.expose-request-attributes:是否开启request属性expose,默认false;8,spring.freemarker.expose-session-attributes:是否开启session属性expose,默认false;9,spring.freemarker.expose-spring-macro-helpers:是否开启spring的freemarker宏支持;默认为false;10,spring.freemarker.prefer-file-system-access:默认为true,支持实时检查模板修改;11,spring.freemarker.prefix:加载模板时候的前缀;12,spring.freemarker.settings.*:直接配置freemarker参数13,spring.freemarker.suffix:模板文件后缀;14,spring.freemarker.template-loader-path=classpath:/templates/:模板加载地址

application.properties

spring.freemarker.charset=UTF-8spring.freemarker.content-type=text/html;charset=UTF-8spring.freemarker.expose-session-attributes=true

1).@ControllerAdvice通过使用@ControllerAdvice定义统一的异常处理类,而不是在每个Controller中逐个定义。@ExceptionHandler用来定义函数针对的异常类型。

GlobalExceptionHandler.java

@ControllerAdvicepublic class GlobalExceptionHandler { //@ExceptionHandler(logicException.class)也可以分情况处理异常@ExceptionHandler(Exception.class)public String errorHandler(Model model, Exception e) { model.addAttribute("error", e.getMessage; //到模板找到err.ftl将错误信息显示出来 return "err"; }}

2)统一的异常页面1,SpringBoot默认情况下,把所有错误都重新定位到/error这个处理路径上,由BasicErrorController类完成处理;2,SpringBoot提供了默认的替换错误页面的路径:1,静态错误页面默认结构:(按照这个目录结构放置错误页面报错时就会自动找到相应的界面)src/ resources/public/error/404.htmlsrc/ resources/public/error/ 403.htmlsrc/ resources/public/error/ 5xx.html

2,也可以使用模板页面:src/resources/templates/error/5xx.ftl该路径方式是通过ErrorMvcAutoConfiguration中的DefaultErrorViewResolver完成的;

集成DataSource方式1:先加入依赖

<!-- druid --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.0.14</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <scope>runtime</scope> </dependency>

DatasourceController .java

@Controllerpublic class DatasourceController {@Autowiredprivate DataSource dataSource;@RequestMapping@ResponseBodypublic String datasource() { return dataSource.getClass()   " "   dataSource.toString();}}

运行main

@SpringBootApplicationpublic class App { //使用代码的方式实现datasource@Beanpublic DataSource dataSource() { DruidDataSource dataSource = new DruidDataSource(); dataSource.setUrl("jdbc:mysql:///p2p"); dataSource.setUsername; dataSource.setPassword; dataSource.setDriverClassName("com.mysql.jdbc.Driver"); dataSource.setInitialSize; dataSource.setMinIdle; return dataSource;}public static void main(String[] args) { SpringApplication.run(App.class, args);}}

澳门新濠3559 31

集成DataSource方式2:

使用配置文件的方式application.properties

ds.username=rootds.password=123456ds.url=jdbc:mysql:///p2pds.driverClassName=com.mysql.jdbc.Driverds.initialSize=3

App.java

@Bean@ConfigurationProperties(prefix = "ds")public DataSource dataSource(Properties properties) throws Exception { return DruidDataSourceFactory.createDataSource(properties);}public static void main(String[] args) { SpringApplication.run(App.class, args);}

澳门新濠3559 32

集成DataSource方式3:修改配置文件

spring.datasource.username=rootspring.datasource.password=123456spring.datasource.url=jdbc:mysql:///p2pspring.datasource.driverClassName=com.mysql.jdbc.Driverspring.datasource.initialSize=3spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

澳门新濠3559 33

Springboot集成mybatis

mybatis集成:使用mybatis-spring-boot-starter来完成mybatis集成;

1,引入依赖:

<dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>1.3.0</version></dependency>

2,正常完成mapper接口和mapper.xml3,mybatis-spring-boot-starter提供了以下配置(具体参考MyBatisProperties对象):

mybatis.configLocation:mybatis的配置文件地址;mybatis.mapperLocations:映射文件地址;mybatis.typeAliasesPackage:别名扫描包;

spring.datasource.username=rootspring.datasource.password=123456spring.datasource.url=jdbc:mysql:///p2pspring.datasource.driverClassName=com.mysql.jdbc.Driverspring.datasource.initialSize=3spring.datasource.type=com.alibaba.druid.pool.DruidDataSourcemybatis.mapperLocation=classpath:com/jd/springboot/mybatis3/*Mapper.xmlmybatis.typeAliasesPackage=com.jd.springboot.mybatis3

4,使用@MapperScan标签扫描mapper接口

@SpringBootApplication@MapperScan(basePackages="com.jd.springboot.mybatis3") public class App {public static void main(String[] args) { SpringApplication.run(App.class, args);}}

澳门新濠3559 34

1,使用代码的方式:

1,直接开启@EnableTransactionManagement注解;相当于在xml中配置<tx:annotation-driven/>

@SpringBootApplication@MapperScan(basePackages="com.jd.springboot.demo.mybatis1.mapper")@EnableTransactionManagementpublic class App {public static void main(String[] args) { SpringApplication.run(App.class, args);}}

如果在classpath中添加的是spring-boot-starter-jdbc,那么springboot自动创建DataSourceTranscationManager;

@Beanpublic PlatformTransactionManager transactionManager(DataSource dataSource) { return new DataSourceTransactionManager(dataSource);}
如果开启了@EnableTransactionManagement,只需要在service上面使用@Transactional即可;
2,使用xml配置

将事务相关配置抽取到XML中,使用importResource引入

1,引入aop

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency>

2,application-tx.xml

<tx:advice transaction-manager="transactionManager"> <tx:attributes> <tx:method name="list*" read-only="true" /> <tx:method name="get*" read-only="true" /> <tx:method name="query*" read-only="true" /> <tx:method name="*" /> </tx:attributes></tx:advice><aop:config> <aop:pointcut expression="execution(* com.jd.springboot.demo..service.*Service.*" /> <aop:advisor advice-ref="advice" pointcut-ref="pointCut" /></aop:config>

3,引入配置

@SpringBootApplication@MapperScan(basePackages = "com.jd.springboot.demo.mybatis1.mapper")@ImportResource(locations="classpath:application-tx.xml")public class App {}
文件上传

1,仍然使用MultipartFile完成上传,Springboot是使用Servlet3中的Part对象完成上传,不是使用的fileupload;

2,上传相关配置:spring.http.multipart.enabled=true:是否允许处理上传;

spring.http.multipart.maxFileSize=1MB:允许最大的单文件上传大小,单位可以是kb,mb;

spring.http.multipart.maxRequestSize=10MB:允许的最大请求大小;

3,也可以通过创建一个MultipartConfigElement类型的bean对上传进行配置:

@Beanpublic MultipartConfigElement multipartConfigElement() { MultipartConfigFactory mcf = new MultipartConfigFactory(); mcf.setMaxFileSize; mcf.setMaxRequestSize; return mcf.createMultipartConfig();}

4,关于上传文件的处理:因为应用是打成jar包,所以一般会把上传的文件放到其他位置,并通过设置spring.resources.static-locations来完成资源位置映射。

spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/,file:/Users/zhangshuai/devs/workspace/springboot-demo/upload/

SpringBoot总结

1.Maven中项目的继承依赖包的管理第1:在父项目中添加dependency,子项目不需要添加第2:在父项目中添加dependencyManagement标签,然后在添加dependency,子类对应的添加需要的dependency,但不需要写版本号2.项目分为前台和后台两个应用的好处从安全性考虑,后台是给公司管理人员用的,前台是给用户用的,访问的URL地址是不一样的,那这样的话前台用户就不可能通过各种尝试去访问后台管理系统了。从性能方面考虑,项目分成前台和后台把请求分发到不同的服务器中,降低单个服务器的压力。3.什么是乐观锁?乐观锁能解决什么问题?乐观锁(Optimistic Lock): 顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据sql 上的体现:加版本/时间戳控制语句update set version = version 1 ... from .... where version = xxx解决的问题:数据并发问题

4.事务是什么?事务有哪些特性?事务用来干什么?在数据库中,所谓事务是指一组逻辑操作单元,使数据从一种状态变换到另一种状态。特性:

  1. 原子性(Atomicity)原子性是指事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。
  2. 一致性(Consistency)事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
  3. 隔离性(Isolation)事务的隔离性是指一个事务的执行不能被其他事务干扰,即一个事务内部的操作及使用的数据对并发的其他事务是隔离的,并发执行的各个事务之间不能互相干扰。
  4. 持久性(Durability)持久性是指一个事务一旦被提交,它对数据库中数据的改变就是永久性的,接下来的其他操作和数据库故障不应该对其有任何影响

为确保数据库中数据的一致性,数据的操纵应当是离散的成组的逻辑单元:当它全部完成时,数据的一致性可以保持,而当这个单元中的一部分操作失败,整个事务应全部视为错误,所有从起始点以后的操作应全部回退到开始状态。

5.Springboot应用的启动原理?Springboot应用可以在一个主启动类中运行main方法或者打成jar包直接运行该jar包。因为Springboot应用一定会在主启动类贴上一个@SpringBootApplication注解,该注解有包含很多配置,相当于spring的主配置文件,并且springboot应用内嵌web服务器,在我们启动应用时,会先根据@SpringBootApplication注解的配置初始化spring容器,并运行在内嵌的web服务器上。

6.@Configuration标签,@ComponentScan和@Bean标签各自的作用;@Configuration:贴上该注解的类会被spring当成配置对象解析,可以在该配置对象创建bean注入到spring容器(相当于之前我们application.xml写的配置)@ComponentScan:该注解与@Configuration:结合一起使用,可以扫描应用中的组件,比如贴了@Controller,@Service,@Component的类,并注入到spring容器中。此外,改注解可以填写扫描的包路径,如果不写的话就默认扫描贴了该注解的类所在的包及其子包。@Bean:该注解结合@Configuration一起使用,作用是把贴上该注解的方法返回的类注入到spring容器中。7.@ConfigurationProperties标签的作用;该注解起到参数绑定的作用,可以非常方便的把配置文件的配置信息绑定到Properties对象上,并且可以控制到具体哪些前缀的配置信息需要绑定8.日志级别:error>warn>Info>debug>trace

点击查看SpringBoot从入门到高级视频教程

编辑:编程 本文来源:springboot让我们更加简单快速的构建spring应用,本

关键词: 澳门新濠3559