# SpringBoot入门

**Repository Path**: binfan/SpringBootQuickStart

## Basic Information

- **Project Name**: SpringBoot入门
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2017-07-14
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

#SpringBoot入门
-  **第一课 HelloWorld** 
1. 使用IntelJ创建项目工程
NewProject->Spring Initializr->Next ...
创建好后是一个包含了
spring-boot-starter、spring-boot-starter-test两个依赖的功能
2. 这时候距离我们Helloworld工程还是一部那就是引入
spring-boot-starter-web Jar包
3. 然后手写一个RestControler,添加一个RequestMapping即可
```
@RestController
public class IndexController {
    @RequestMapping("/")
    String Index() {
        return "Spring Boot L1";
    }
}
```
4. 再来看单元测试
系统默认生成了一个测试类
添加以下方法：
```
private MockMvc mvc;
	@Before
	public void setUp() throws Exception {
		mvc = MockMvcBuilders.standaloneSetup(new IndexController()).build();
	}
	@Test
	public void getHello() throws Exception {
		mvc.perform(MockMvcRequestBuilders.get("/").accept(MediaType.APPLICATION_JSON))
				.andExpect(MockMvcResultMatchers.status().isOk())
				.andExpect(MockMvcResultMatchers.content().string("Spring Boot L1"));
	}
	@Test
	public void contextLoads() {
	}
```


使用MockMvc对Controler进行方法测试

 **checkout SpringBootL1查看源码** 

-  **第二课 配置文件与属性加载** 
1. 动态赋值配置
application.properties中可以对程序运行时的参数进行设置
格式是yaml，当然也可以使用别的xml，json等
代码中可以使用@Value注解进行读取属性
 _@Value("${属性名}")_ 
eg：代码中建立了一个属性类Project
然后声明了两个属性
```
@Component
public class Project {
    @Value("${project.author}")
    private String author="spring";
    @Value("${project.type}")
    private String type="springMVC";
```
然后在application.properties中配置对应属性即可
2. 多环境切换
工作制用得最多的就是多环境切换了，开发环境，测试环境，预发布环境，线上环境等等
在Springboot中可以使用application-xxx.properties来对应配置，然后在主的
application.properties中使用 spring.profiles.active=xxx 即可激活对应文件的配置非常方便。

checkout SpringBootL2 查看源代码

-  **第三课 RestfulAPI实践** 
首先简单说明下SpringMVC的注解
@Controller：修饰class，用来创建处理http请求的对象
@RestController：Spring4之后加入的注解，原来在@Controller中返回json需要@ResponseBody来配合，如果直接用@RestController替代@Controller就不需要再配置@ResponseBody，默认返回json格式。
@RequestMapping：配置url映射

这里我们创建了一个UserController，简单实现用户的CRUD
```
@RequestMapping("/user")
@RestController
public class UserController {
    private ConcurrentHashMap<Integer, User> userMap = new ConcurrentHashMap<>();

    @RequestMapping(value = "", method = RequestMethod.POST)
    String addUser(@ModelAttribute User user) {
        if(userMap.containsKey(user.getId())) {
            return "already exist";
        }
        userMap.put(user.getId(), user);
        return "success";
    }

    @RequestMapping(value = "/{id}", method = RequestMethod.PUT)
    String updateUser(@PathVariable("id") Integer id, @ModelAttribute User user) {
        if(userMap.containsKey(user.getId())) {
            userMap.put(user.getId(), user);
            return "success";
        }
        return "not exist";
    }

    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
    String delUser(@PathVariable("id") Integer id){
        userMap.remove(id);
        return "success";
    }

    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    String getUser(@PathVariable("id") Integer id) {
        if(userMap.containsKey(id)) {
            return userMap.get(id).getName();
        } else {
            return "not found";
        }
    }

    @RequestMapping(value = "", method = RequestMethod.GET)
    List<User> getUserList() {
        return new ArrayList<>(userMap.values());
    }
}
```
单元测试部分具体见工程代码
checkout SpringBootL3

-  **第四课使用模板引擎 thymeleaf** 
spring1.5.x以后移除了velocity的支持，所以这里使用thymeleaf模板
引入也很简单：
```
     <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
```
不配置的话默认模板位置位于
resources/templates
springboot的静态资源默认在 resoures/static
然后新建一个RequestMapping映射到模板即可测试
```
    @RequestMapping("/h5")
    String H5Index(Model model) {
        model.addAttribute("host", "http://vv-tech.com");
        return "index";
    }
```
具体代码 checkout SpringbootL4
- 使用Swagger构建Restful API文档
1. 增加包引用
```
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger2</artifactId>
			<version>2.2.2</version>
		</dependency>
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger-ui</artifactId>
			<version>2.2.2</version>
		</dependency>
```
2. 增加配置类
```
@Configuration
@EnableSwagger2
public class Swagger2 {
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.example.demo.web"))
                .paths(PathSelectors.any())
                .build();
    }
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("Spring Boot中使用Swagger2构建RESTful APIs")
                .description("更多Spring Boot相关文章请关注：http://blog.didispace.com/")
                .termsOfServiceUrl("http://blog.didispace.com/")
                .contact("xnby@foxmail.com")
                .version("1.0")
                .build();
    }
}
```
通过@Configuration，@EnableSwagger2来启用
然后apis（）设置扫描的controller，paths可以设置正则过滤

3. 注解API
```
 @ApiOperation(value="更新用户详细信息", notes="根据url的id来指定更新对象，并根据传过来的user信息来更新用户详细信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "用户ID", required = true, dataType = "Long"),
            @ApiImplicitParam(name = "user", value = "用户详细实体user", required = true, dataType = "User") 
    })
//使用注解来修饰Api接口
@ApiOperation
@ApiImplicitParams
@ApiImplicitParam
```
- 第六课统一异常处理
1. 使用@ControllerAdvice定义异常处理类
```
    @ExceptionHandler(value = Exception.class)
    public ModelAndView defaultErrorHandler(HttpServletRequest req, Exception e) throws Exception {
        ModelAndView mav = new ModelAndView();
        mav.addObject("exception", e);
        mav.addObject("url", req.getRequestURL());
        mav.setViewName(DEFAULT_ERROR_VIEW);
        return mav;
    }

    @ExceptionHandler(value = JsonRetException.class)
    @ResponseBody
    public BaseResp<Null> APIErrorHandder(HttpServletRequest req, JsonRetException e) throws Exception {
        return new BaseResp<>(e.getLocalmsg().getErrorCode(), e.getLocalmsg().getErrorMsg(), null);
    }
```
2. 定义错误页面返回或者Json返回
代码见上面
3. 在Controller中抛出异常

- JDBC Template 连接Mysql
1. 添加Jar包引用
```
		<!--数据库依赖-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.21</version>
		</dependency>
```
2. 配置jdbc路径
```
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=111111
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
```
3. 增加业务代码
jdbcTemplate可以自动装配
```
@Service
public class UserServicesImpl implements UserServices {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public void create(String name, Integer age) {
        jdbcTemplate.update("insert into USER(NAME, AGE) values(?, ?)", name, age);
    }
    @Override
    public void deleteByName(String name) {
        jdbcTemplate.update("delete from USER where NAME = ?", name);
    }
    @Override
    public Integer getAllUsers() {
        return jdbcTemplate.queryForObject("select count(1) from USER", Integer.class);
    }
    @Override
    public void deleteAllUsers() {
        jdbcTemplate.update("delete from USER");
    }
}
```
- 第八课 使用 Spring-data-jpa
Spring-data-jpa可以自动生成对应的数据库表及查询文件
使用起来较为方便。
1. 添加引用
```
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
```
2. 增加配置
```
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=111111
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.jpa.properties.hibernate.hbm2ddl.auto=update
```
3. 增加实体类
```
@Entity
public class UserProfile {
    @Column(nullable = false)
    private String nickname;
    @Column()
    private Date birthday;
    @Column(nullable = false)
    private Short sex;
    @Column
    private int age;
    @Column
    private String email;
    @Column(nullable = false)
    private String phone;
    @Column
    private String sign;
    @Column(nullable = false)
    private String avator;
    @Column(nullable = false)
    private int userId;

    @Id
    @GeneratedValue
    private int proId;
```
4. 编写Repository
```
public interface UserProfilePeopository extends JpaRepository<UserProfile, Long> {
    UserProfile findByUserId(Integer userId);
    UserProfile findByNickname(String nickname);
    UserProfile findByNicknameAndAge(String nickname, Integer age);
    @Query("from UserProfile u where u.nickname=:nickname")
    UserProfile findUserProfile(@Param("nickname") String nickname);
}

```
- 第九课 多数据源的配置实现
1. 修改配置属性，增加2个配置项
```
spring.datasource.primary.url=jdbc:mysql://localhost:3306/test
spring.datasource.primary.username=root
spring.datasource.primary.password=111111
spring.datasource.primary.driver-class-name=com.mysql.jdbc.Driver

spring.datasource.secondary.url=jdbc:mysql://localhost:3306/guns
spring.datasource.secondary.username=root
spring.datasource.secondary.password=111111
spring.datasource.secondary.driver-class-name=com.mysql.jdbc.Driver
```
2. 增加Config类构造对应的DataSource和JdbcTemplate
```
@Configuration
public class DataSourceConfig {
    @Bean(name = "primaryDataSource")
    @Qualifier("primaryDataSource")
    @ConfigurationProperties(prefix="spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }
    @Bean(name = "secondaryDataSource")
    @Qualifier("secondaryDataSource")
    @Primary
    @ConfigurationProperties(prefix="spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
    @Bean(name = "primaryJdbcTemplate")
    public JdbcTemplate primaryJdbcTemplate(
            @Qualifier("primaryDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
    @Bean(name = "secondaryJdbcTemplate")
    public JdbcTemplate secondaryJdbcTemplate(
            @Qualifier("secondaryDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}
```
3. 代码中通过注解选择构造指定的JdbcTemplate
```
    @Autowired
    @Qualifier("primaryJdbcTemplate")
    private JdbcTemplate jdbcTemplate;
    @Autowired
    @Qualifier("secondaryJdbcTemplate")
    private JdbcTemplate jdbcTemplateSerd;
```
4. 增加JPA的不同配置类
具体见代码
5. 在不同的配置类包路劲下编写业务逻辑
具体见代码

- 使用myBatis+PageHelper+myBatisGenerator+Durid
这个东西比较复杂比较多，具体还是参看代码比较好
1. 引入Jar包
```

		<!--mybatis-->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.0</version>
		</dependency>
		<!--mapper-->
		<dependency>
			<groupId>tk.mybatis</groupId>
			<artifactId>mapper-spring-boot-starter</artifactId>
			<version>1.1.2</version>
		</dependency>
		<!--pagehelper-->
		<dependency>
			<groupId>com.github.pagehelper</groupId>
			<artifactId>pagehelper-spring-boot-starter</artifactId>
			<version>1.1.2</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.1.0</version>
		</dependency>
```
2. 引入generatorPlugin
```
<plugin>
				<groupId>org.mybatis.generator</groupId>
				<artifactId>mybatis-generator-maven-plugin</artifactId>
				<version>1.3.2</version>
				<configuration>
					<configurationFile>${basedir}/src/main/resources/mybatis/generatorConfig.xml</configurationFile>
					<overwrite>true</overwrite>
					<verbose>true</verbose>
				</configuration>
				<dependencies>
					<dependency>
						<groupId>mysql</groupId>
						<artifactId>mysql-connector-java</artifactId>
						<version>${mysql.version}</version>
					</dependency>
					<dependency>
						<groupId>tk.mybatis</groupId>
						<artifactId>mapper</artifactId>
						<version>3.4.0</version>
					</dependency>
				</dependencies>
			</plugin>
```
3. 增加配置文件
```
spring.datasource.druid.initial-size=1
spring.datasource.druid.min-idle=1
spring.datasource.druid.max-active=20
spring.datasource.druid.test-on-borrow=true
spring.datasource.druid.stat-view-servlet.allow=true

mybatis.type-aliases-package=com.example.demo.mybatis.model
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml
mapper.mappers=com.example.demo.mybatis.util.MyMapper
mapper.not-empty=false
mapper.identity=MYSQL
pagehelper.helperDialect=mysql
pagehelper.reasonable=true
pagehelper.supportMethodsArguments=true
pagehelper.params=count=countSql
```

4. 增加@MapperScan(basePackages = "com.example.demo.mybatis.mapper")注解
新建mybatisConfig或者直接写到Application类去

- 12课 日志记录
Spring Boot在所有内部日志中使用Commons Logging，但是默认配置也提供了对常用日志的支持，如：Java Util Logging，Log4J, Log4J2和Logback。每种Logger都可以通过配置使用控制台或者文件输出日志内容。
- 文件输出
若要增加文件输出，需要在application.properties中配置logging.file或logging.path属性。
 _logging.file=my.log
logging.path=/var/log_ 
- 级别控制
 _logging.level.*=LEVEL
logging.level：日志级别控制前缀，*为包名或Logger名
LEVEL：选项TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF_ 
- 自定义日志
_Logback：logback-spring.xml, logback-spring.groovy, logback.xml, logback.groovy
Log4j：log4j-spring.properties, log4j-spring.xml, log4j.properties, log4j.xml
Log4j2：log4j2-spring.xml, log4j2.xml
JDK (Java Util Logging)：logging.properties_