SpringBoot 入门篇

1. Spring Boot简介

springboot是由picotal团队提供的一款框架，设计的目的是简化spring应用的初始搭建和开发过程；
简单理解：springboot其实更像是预先将spring应用的项目的框架搭建所需要的配置配置好，相关的依赖也约定好；等到开发人员开发的时候，不再需要写固定的xml配置；如一个ssm项目，如果导入依赖了springboot，那么所有的集成用的配置文件xml都可以不用写；
总结说：springboot就是使编码更简单，使配置更简单，使部署更简单，使监控更简单；

2. springboot功能

无需手动管理依赖jar包的版本；
简单理解：像是一个maven的项目，如果我们需要做一个web项目，要集成到springmvc，那么只需要在pom文件中引入springboot的依赖以及spring-boot-starter-web这样一个依赖，那么就以及集成了springmvc以及tomcat；也就是说可以直接实现controller做页面数据传递了；再导入jsp编译相关的依赖，再做简单配置就能实现页面跳转；可以说是非常的方便了；你再也不用写applicationContext.xml这样的配置；
SpingBoot提供的Starters：也就是已经集成配置好的一些框架；
可以看到springboot提供的一些集成配置，只需要在pom中简单引入就好；这些就是预先做好的配置， 所谓的约定大于配置；

3.springboot入门

1.创建一个maven项目；在pom.xml中导入相关依赖；

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.5.10.RELEASE</version>
</parent>


java.version 指定jdk版本号：
<java.version>1.8</java.version>

添加spring-boot-starter-web依赖
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>

导入上面的相关依赖，就已经集成了springmvc和tomcat；这是内置的tomcat，也就是不再需要做额外的部署；并且springboot还提供了一个很牛逼的热部署的功能；在启动了这个服务application后，即使是添加了方法，修改了什么内容，都不需要重新启动；
热部署依赖包：

<!-- 热部署 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>	

2.启动application；这里需要定义启动类，它的功能就像是启动服务，这里其实就是启动应用层序；
要注意的地方：这个启动类最好是放到项目包的根目录下；

@SpringBootApplication
public class RunApp {
	public static void main(String[] args) throws Exception {
        SpringApplication.run(RunApp.class);
    }
}

测试：定义controller测试向前台页面中传递数据；
注意：这里要使用到@restController的一个注解；它是表示只传递数据不做页面跳转；类似于加@Responsbody的作用；一般在移动端应用上用得比较多；这里可以使用该注解来实现数据传递，但是不做页面跳转；

@RestController
public class HelloController {
    @RequestMapping("/")
    String home() {
        return "Hello World!";
    }
}

访问：localhost:8080就可以获得传递的数据在页面中；这里的tomcat的端口好是它内置的默认端口号；当然也是可以通过配置修改的；springboot有很多的默认设置，都是可以通过一个application.properties/application.yml来自定义；可以根据官网来查看有哪些属性值可以设置springboot默认Common application properties

4.SpringBoot的application.properties/application.yml

说以下springboot的使用中要使用到的很重要的两个配置文件application.properties/application.yml；说是两个配置，但是其实这两个文件只是做属性设置的两种方式而已；可以使用其中一个，也可以两个都使用；如果两个都使用底层会取两个文件配置内容的并集来加载；
先说里面可以配置哪些内容：根据官网中的介绍，说几个重要的；
1.设置内置的tomcat的端口号；
2.设置数据库链接属性（username,password,diver,url）;
3.mvc的视图解析器配置；
4.集成mybatis的时候别名，mapper.xml文件的扫描；
5.自定义属性和值（可以在controller中使用@value注解取出来使用）；
等等。。还有很多是属性都可以通过官网文档查看官网属性查看 ；
application.properties:
这种配置方式就是普通的properties的配置方式；但是要注意按照官网文档中的样子来定义；
如端口号配置：官网中是这样的：可以看到这里就是默认给的8080端口号；所以刚才测试的时候是访问8080；
因此在application.properties中就重新定义然后覆盖默认值的设置就必须按照这个格式来做；
application.yml:
那么application.yml这个配置文件其实也所相同的事情；但是它可以以更简单的方式来定义属性，能够替代properties的方式；不过要写application.yml需要注意以下几点规则，否则定义的形式是不对的；eclipes中有插件可以用来检测application.yml是否写错，如果格式不对会报错；
下面贴一个可能常用到的几个配置，使用application.yml的方式；
要点
application.yaml 配置文件如下，注意换行按Tab键，冒号之后空格。
缩进时不允许使用Tab键，只允许使用空格。
缩进的空格数目不重要，只要相同层级的元素左侧对齐即可

#application.yaml 配置文件如下，注意换行按Tab键，冒号之后空格。
#缩进时不允许使用Tab键，只允许使用空格。
#缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
# Tomcat
server:
    tomcat:
        uri-encoding: UTF-8
        max-threads: 1000
        min-spare-threads: 30
    port: 8080
    connection-timeout: 5000
    context-path: /hp-cloud-im-web
spring:
    # 环境 dev|test|pro
    profiles:
        active: dev
        #include: mybatis
    mvc:
        view:
              prefix: /WEB-INF/view/ 
              suffix: .jsp  
    # jackson时间格式化
    jackson:
        time-zone: GMT+8
        date-format: yyyy-MM-dd HH:mm:ss
    http:
        multipart:
            max-file-size: 100MB
            max-request-size: 100MB
            enabled: true
   # Spring devtools
    devtools:
        restart:
        enabled: true     

# Mybatis配置
mybatis:
    mapperLocations: classpath:org/kd/dao/mapper/*.xml
    configLocation: classpath:mybatisConfig.xml
# 通用 mapper    
mapper:
    mappers:
        - org.kd.common.base.BaseMapper
    not-empty: false
    identity: MYSQL

5.jsp页面跳转

上面的测试成功后就说明已经可以使用springmvc，并且内置的tomcat也是部署好的；还可以热启动，爽歪歪；现在就可以集成一些，做一个页面跳转；
1.导入编译jsp文件的依赖包；(很重要，这个很容易忘，如果没有包直接就用不起)

<!--必须有才能编译jsp -->
<dependency>
	<groupId>org.apache.tomcat.embed</groupId>
	<artifactId>tomcat-embed-jasper</artifactId>
	<scope>provided</scope>
</dependency>

2.配置视图解析器；和常规的使用方式一样，传统的集成中要在applicationContext-mvc.xml中定义视图解析器；也就是页面的前缀后缀；现在也需要我们配置一手；因为这个都是自定义的东西，springboot不可能直接给你预先配置好；
配置方式：这里使用application.yml来配置；注意严格按照ymal的格式要求写；

spring:
# 页面跳转的前缀后缀设置
 mvc:
   view: 
     prefix: /WEB-INF/jsp/
     suffix: .jsp

3.编写跳转controller
这就和没有集成springboot的方式一样了；都是常规写，springboot只是帮助我们减少了一些模板化的配置；java代码还是正常写；

@Controller
public class IndexController {
	/**
	 * 返回页面并传递参数
	 * @param request
	 * @return
	 */
	@RequestMapping("/index")
	public String index(HttpServletRequest request){
		request.setAttribute("name", "小明");
		return "index";
	}
}

json数据的传递：也是一样的方式使用注解传递就行了；

6.集成myBatis

1.创建maven项目
2.导入springboot的基本依赖，jdk版本号的设置,web依赖包，还有mysql驱动依赖，mybatis的依赖，必要的化还可以导入分页插件，springboot的测试依赖也可以导入一个（测试依赖可以让测试变得方便，可以每次调用测试方法的时候自动启动app应用程序）；（pom.xlm中完成）

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.5.10.RELEASE</version>
</parent>

<!--java.version 指定jdk版本号：-->
<java.version>1.8</java.version>

添加spring-boot-starter-web依赖
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- springboot 测试的包 -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-test</artifactId>
</dependency>

<!-- 数据库依赖包 -->
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
</dependency>

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

	<!-- spring boot mybatis 分页插件 -->
<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper-spring-boot-starter</artifactId>
	<version>1.2.2</version>
</dependency>

3.配置application.yml（数据库链接属性的配置，myBatis的mapper.xml映射文件扫描配置）

# 配置数据库链接属性；也是spring下面的，所以和mvc一个层级
spring: 
 datasource:
    driverClassName: com.mysql.jdbc.Driver
    url : jdbc:mysql://localhost:3306/spring-boot-demo?useUnicode=true&characterEncoding=utf-8 
    username : root
    password : 123456
# Mybatis配置
mybatis:
 typeAliasesPackage: cn.itsource.model
 mapperLocations: classpath:cn/itsource/dao/mapper/*.xml

4.启动类中添加注解，对mapper映射接口做扫描；
配置后会扫描指定包下面的接口；

@SpringBootApplication
@MapperScan("cn.itsource.dao")
public class RunApp {
	public static void main(String[] args) throws Exception {
        SpringApplication.run(RunApp.class, args);
    }
}

5.准备数据库，表，数据，实体对象；这些就不多说了
6.编写mapper接口，可以使用注解方式，xml方式都可以；和常规的myBatis的使用一样；
这里要使用一个mapper的注解了；启动app的时候可以扫描到这里；

@Mapper
public interface IUserDao{

	//查询所有
	@Select("select * from t_user")
	List<User> queryAll();
	
	//查询一条数据
	@Select("select * from t_user where id=#{id}")
	User queryOne(Integer id);
	
	//插入一条数据
	void saveUser(User user);
	
	//删除一条数据
	@Delete("delete from t_user where id = #{id}")
	void deleteUser(Integer id);
	
	//修改一条数据
	void updateUser(User user);
	
	//分页方法
	PageInfo<User> pageQuery(Integer pageNum,Integer pageSize);
	
}

mapper.xml文件：myBatis的重要优点，动态sql就可以随你操作了；

<?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 namespace="cn.itsource.dao.IUserDao">
 
 <insert id="saveUser" parameterType="cn.itsource.model.User">
 	insert into t_user(name,age) values(#{name},#{age})
 </insert>
 
 <!-- 修改数据 -->
 <update id="updateUser" parameterType="User">
 	update t_user 
 	<set>
 		<if test="name != null and name != ''">
 			name = #{name},
 		</if>
 		<if test="age != null and age != ''">
 			age = #{age},
 		</if>
 	</set>
 	where id = #{id}
 </update>
</mapper>

7.service层相同的完成接口和实现类就行；于常规方式相同；这时会惊奇的发现，要注入的mapper接口可以直接注入；而我们又没有做任何的配置，只是在pom中导入了支持的依赖，其他的配置文件，都由springboot预先完成了，这就是springboot的好处；

8.测试
新建测试包测试类；这里要使用一个springboot的测试用的注解；之前导入依赖的时候已经导入了；@SpringBootTest(classes=RunApp.class)；其实就是加载启动类，测试的时候就不需要再单独启动应用程序，直接跑测试的方法，应用自己就会启动，测试完成也会自动关闭，不会一直挂着；
我的完整测试代码：

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes=RunApp.class)
public class MyBatisTest {

	@Autowired
	private IUserService userService;
	@Test
	public void testQueryAll() throws Exception {
		List<User> list = userService.queryAll();
		for (User user : list) {
			
			System.out.println(user);
		}
	}
	
	//查询一条数据
	@Test
	public void testQueryOne() throws Exception {
		System.err.println(userService.queryOne(1));
	}
	public User queryOne(Integer id) throws Exception {
		return userService.queryOne(id);
	}
	//插入一条数据
	@Test
	public void testSave() throws Exception {
		User user = new User();
		user.setName("xxx");
		user.setAge(18);
		userService.saveUser(user );
	}
	//删除一条数据
	@Test
	public void testDelete() throws Exception {
		userService.deleteUser(6);
	}
	//修改一条数据
	@Test
	public void testUpdate() throws Exception {
		User user = queryOne(2);
		user.setName("张");
		userService.updateUser(user);
	}
	/**
	 * 分页查询
	 * @throws Exception
	 */
	@Test
	public void testPageQuery() throws Exception {
		PageInfo<User> pageInfo = userService.pageQuery(1, 2);
		for (User user : pageInfo.getList()) {
			System.out.println(user);
		}
	}
}

9.补充一点
关于事务，直接使用@transactional注解；总结：springboot其实就是简化了以往集成框架的时候必要的xml配置文件的步骤；将一些模板化的固定不变的配置预先做好了；而且对一依赖的包也直接做了管理和集成，提供给我们的都是已经集成好的依赖，我们不需要关心版本，也不需要关心所有的依赖是怎样的，只需要导入很少的几个依赖，做很少的需要自定义的配置；就可以完成一个简单的myBatis的集成；使用上确确实实的很大幅度的减少了框架的配置过程；