很久以前的一篇 日报

日报day01

SpringBoot的使用环境

1 jdk的版本要>= 1.8
2 maven的版本大于等于3.3
3 tomcat的版本大于等于9.0（使用tomcat的话）

##SpringBoot项目的小demo实现
创建一个maven项目，然后在pom中引入父工程（加上SpringBoot的web起步依赖和jdk版本）。

`

org.springframework.boot
spring-boot-starter-parent
2.1.6.RELEASE

<properties>
    <java.version>1.8</java.version>
</properties>

<!--依赖-->
<dependencies>
    <!--SpringBoot的web起步依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

1. 在java文件夹下创建启动类Application。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication //springboot的核心
public class Application {

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

2.对启动类进行启动；

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication //springboot的核心
public class Application {

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

3. 编写demo进行简单访问；

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class IndexController {

   @RequestMapping("/index")
   public Object index(){
       return "Hello,SpringBoot!";
   }
}

1. 成功访问：
   
   #简单表的CRUD
   1 添加依赖并在application.properties中配置mybatis。

 <!--连接mysql-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        
        <!--java连接mysql数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

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

        <!-- 通用mapper -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.0.2</version>
        </dependency>

2 然后创建Controller、Service、Mapper、pojo。

Controller：

package com.leyou.controller;

import com.leyou.pojo.User;
import com.leyou.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("/findUserById")
    private User findUserById(Integer id){
        User user = userService.findUserById(id);
        System.out.println(user);
        return user;
    }

    @RequestMapping("/queryAll")
    public Object queryAll(){
        List<User> userList = userService.queryAll();
        return userList;
    }

    @RequestMapping("/insertUser")
    public void insertUser(User user){
        userService.insert(user);
    }

    @RequestMapping("/updateUser")
    public void updateUser(User user){
        userService.updateUser(user);
    }

    @RequestMapping("/deleteById")
    public void deleteById(Integer id){
        userService.deleteById(id);
    }
}

Service：

package com.leyou.service;

import com.leyou.dao.UserMapper;
import com.leyou.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User findUserById(Integer id) {
        return userMapper.selectByPrimaryKey(id);
    }

    public void insert(User user) {
        userMapper.insertSelective(user);
    }

    public void updateUser(User user) {
        userMapper.updateByPrimaryKeySelective(user);
    }

    public void deleteById(Integer id) {
        User user = new User();
        user.setId(id);
        userMapper.deleteByPrimaryKey(user);
    }

    public List<User> queryAll() {
        return userMapper.selectAll();
    }
}

Mapper：

package com.leyou.dao;

import com.leyou.pojo.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User>{
}

Pojo：

package com.leyou.pojo;

import javax.persistence.Id;

public class User {
	//该注解一定加上，它可以将该id属性映射到数据库表中的自增字段
    @Id
    private Integer id;
    private String name;
    private Integer age;

    public User() {
    }

    public User(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3 测试类的编写
直接在测试类对某方法进行点击测试，要加上@SpringBootTest注解，其中的class是自己编写的启动类的class文件，如果不写SpringBoot不能启动，测试失败。

package com.leyou.pojo;

import com.leyou.Application;
import com.leyou.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class UserTest {

    @Autowired
    private UserService userService;

    @Test
    public void findById(){
        User user = userService.findUserById(2);
        System.out.println(user);
        System.out.println("query complate!");
    }

    @Test
    public void insertUser(){
        userService.insert(new User(null,"www",14));
        System.out.println("insert complate!");
    }

    @Test
    public void updateUser(){
        userService.updateUser(new User(1,"修改成功",14));
        System.out.println("Update complate！");
    }

    @Test
    public void deleteById(){
        userService.deleteById(1);
        System.out.println("delete complate!");
    }
}

注意点
1 springBoot的核心配置文件为application.properties，也可以写成application.yml的形式。但是，两种配置文件是可以并行存在，但在此情况下SpringBoot默认使用以properties结尾的配置文件。
2 properties和yml的语法格式不同，比如对服务器端口号进行修改：
Properties：
server.port=8080
yml:

3 SpringBoot自带有hikariCP连接池，在进行使用时，版本较高，在对连接池进行配置时，要加上中国东八区的时区（driverClassName属性可以省略，SpringBoot会自动识别后进行配置）。

4 @Id注解的作用
声明一个实体类属性将映射到数据库主键的字段，在上边的pojo的代码中，如果id属性没有加上@id注解，那么在数据库中对表执行sql时，只要涉及到主键id，那么简单地查修删语句都是无效的。