spring boot

1、 创建一个maven工程

2、pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.1.5.RELEASE</version>
    </parent>
    <groupId>com.tuy</groupId>
    <artifactId>learn_springboot</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <!--  设置jdk的版本      -->
        <java.version>1.8</java.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.11</version>
            </dependency>
        </dependencies>
    </dependencyManagement>


    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

        <dependency>
            <groupId> org.springframework.boot </groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <!--不传递依赖-->
            <optional>true</optional>
        </dependency>

        <!-- 在ide最好也装上插件lombok  -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--   整合事务配置需要的依赖包    -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

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

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

        <!-- 整合junit -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

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

    </dependencies>



    <build>
        <finalName>qc-report</finalName>
        <plugins>
            <!-- 打jar包时如果不配置该插件，打出来的jar包没有清单文件   -->
            <!--    在ide 运行的时候  需要把这里注释掉 ，打包的时候在打开       -->
            <!--    打包命令  maven package  ,到打包的路径，启动项目  java -jar  qc-report.jar   -->
<!--            <plugin> <groupId>org.springframework.boot</groupId>-->
<!--                <artifactId>spring-boot-maven-plugin</artifactId>-->
<!--            </plugin>-->

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.1</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>

3、在resource 下编写 配置文件 application.yml    ,配置文件名字一定要叫这个

jdbc:
  driverClassName: com.mysql.cj.jdbc.Driver
  url: jdbc:mysql://localhost:3306/test1?serverTimezone=UTC&userSSL=false&characterEncoding=utf-8
  username: root
  password: root

  #激活配置文件，需要指定其他配置文件名称(application-后面的名称)
spring:
  profiles:
    active: abc
#数据源（数据连接池的配置），默认使用Hikari数据库连接池，配置后就有数据源对象了
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test1?serverTimezone=UTC&userSSL=false&characterEncoding=utf-8
    username: root
    password: root
#redis配置
  redis:
    host: localhost
    port: 6379

#修改tomcat端口
server:
  port: 8081

  #日志记录级别
logging:
  level:
    com.tuy: debug
    org.springframework: info

#mybatis 配置
mybatis:
  #配置实体类别名包路径
  type-aliases-package: com.tuy.pojo
  #映射文件路径
  #mapper-locations: classpath:mapper/*.xml
  #日志配置
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

 application-abc.yml 文件（另外一个配置文件， 测试用的）

itttest:
  name: http:localtest

 

4、创建包com.tuy.config ,  在包下 创建配置类  MvcConfig

package com.tuy.config;

import com.tuy.interceptor.MyInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

//mvc配置类
@Configuration
public class MvcConfig implements WebMvcConfigurer {

    //注册拦截器
    @Bean
    public MyInterceptor myInterceptor(){
        return new MyInterceptor();
    }

    //添加拦截器到spring mvc拦截器链
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor()).addPathPatterns("/*"); //拦截所有请求路径
    }


}

5、创建包com.tuy.interceptor,  在包下 创建拦截器类  MyInterceptor

package com.tuy.interceptor;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//sping-mvc 拦截器             执行controller里面的方法会调用这个类方法
@Slf4j           //日志
public class MyInterceptor implements HandlerInterceptor
{

    //前置 ，执行处理器之前执行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
       log.debug("这是MyInterceptor.preHandle方法");
        return true; //返回false就是被拦截了 ，不会继续执行
    }

    //后置 ，执行处理器之后执行
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.debug("这是MyInterceptor.postHandle方法");
    }

    //完成时 ，整个页面渲染了执行
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.debug("这是MyInterceptor.afterCompletion方法");
    }
}

 

6、创建包com.tuy.config ,  在包下 创建配置类  MvcConfig

package com.tuy.config;

import com.tuy.interceptor.MyInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

//mvc配置类
@Configuration
public class MvcConfig implements WebMvcConfigurer {

    //注册拦截器
    @Bean
    public MyInterceptor myInterceptor(){
        return new MyInterceptor();
    }

    //添加拦截器到spring mvc拦截器链
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor()).addPathPatterns("/**"); //拦截所有路径

    }


}

 

7、 新建com.tuy.pojo包 ，在包下 创建实体类 User

package com.tuy.pojo;

import lombok.Data; //lombok
import lombok.extern.slf4j.Slf4j;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;

//数据库表的实体类

//在编译阶段会根据注解自动生成对应的方法；data包含get/set/hashCode/equals/toString等方法
@Data
//@Slf4j      //自动在bean中提供log变量，其实用的是slf4j的日志功能。
@Table(name="tb_user")      //查询tb_user 这个表的数据的时候就会映射到这个实体类
public class User {

    @Id             //主键
    @KeySql(useGeneratedKeys = true)    //主键回填 ， 就是插入一条数据后，主键会填到这里
    private Long id;

    //user_name --> userName
    //@Column(name="abc") //当变量名和数据名不同或非常奇怪的时候，要添加@Column
    private String userName;

    private String password;

    private String name;

    private Integer age;

    private Integer sex;

    private Date birthday;

    private String note;

    private Date created;

    private Date updated;
}

8、新建包com.tuy.mapper ，在包下 创建 UserMapper 接口

package com.tuy.mapper;

import com.tuy.pojo.User;
import tk.mybatis.mapper.common.Mapper;

public interface UserMapper extends Mapper<User> {
}

9、创建包 com.tuy.service  ，创建下UserService类

package com.tuy.service;

import com.tuy.mapper.UserMapper;
import com.tuy.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

//业务类
@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    
    //根据id查询
    public User queryById(Long id)
    {
        return userMapper.selectByPrimaryKey(id);
    }
    //新增保存用户
    @Transactional    //需要事务就添加这个注解， 涉及多个操作的时候
    public void saveUser(User user)
    {
        System.out.println("save User......");
        //userMapper.insert(user);
        //选择性新曾，如果属性为空 则该属性不会出现在insert语句上
        userMapper.insertSelective(user);
    }

}

//鼠标点中类名，按shift+ctr+t ,创建测试

 

10、 新建包 com.tuy.controller  在包下，创建 HelloController 类

package com.tuy.controller;

import com.tuy.pojo.User;
import com.tuy.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;
import java.sql.SQLException;

@RestController         //这个类的方法的返回内容都当做字符结果输出
public class HelloController {

    @Autowired          //使用在字段上用于根据类型依赖注入
    private DataSource dataSource;

    @Value("${itttest.name}")
    private String itttestName;

    //注入业务对象
    @Autowired
    private UserService userService;


    /**
     * 根据用户id查询用户
     * @param id  用户id
     * @return 用户
     */
    @GetMapping("/user/{id}")   //http://localhost:8080/user/8
    public User queryById(@PathVariable Long id)    //@PathVariable  路径变量
    {
        return userService.queryById(id);
    }


    //http://localhost:8080/hello
    @GetMapping("hello")
    public String hello() throws SQLException {
        System.out.println("datasource = "+dataSource);
        System.out.println("datasource conn= "+dataSource.getConnection());
        System.out.println(itttestName);

        return "hello,Spring Boot";
    }

}

 

 

11、在包 com.tuy 下创建 Application 类入口 ，每个spring boot 都有这样的程序入口

package com.tuy;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;

/**
 * spring boot工程都有一个启动引导类，这是工程的入口，
 * 在引导类添加注解 @SpringBootApplication
 */
@SpringBootApplication
//@MapperScan("com.tuy.mapper")    //扫描mybatis所有的业务mapper接口 ，指定的是接口所在包路径  ， spring官方的
@MapperScan("com.tuy.mapper")   //通用mpper ,  这个在包tk.mybatis.spring.annotation.MapperScan下，  通用Mapper的
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}
/*
* 出现程序包org.springframework.boot不存在 错误，需要设置
* File-Setting-Maven-Runner 勾选Delegate IDE build/run action to Maven
 */

12、  在 Application类里面启动运行  

13、项目的部署

把 pom.xml 的下面注释打开

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

然后 package  , 到打包的路径，启动项目  命令    java -jar qc-report.jar

 

//--------

对 UserService 类的测试类

package com.tuy.service;

import com.tuy.pojo.User;
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;

import java.util.Date;

import static org.junit.Assert.*;


//注意测试类的也要在包 com.tuy 下

@RunWith(SpringRunner.class)
@SpringBootTest             //springboot测试必须要加
public class UserServiceTest2 {

    @Autowired
    private UserService userService;


    @Test
    public void queryById() {
        User user = userService.queryById(8L);
        System.out.println(user);
    }

    @Test
    public void saveUser() {
        User user=new User();
        user.setUserName("test1");
        user.setName("test1");
        user.setAge(10);
        user.setPassword("123456");
        user.setSex(1);
        user.setCreated(new Date());
        userService.saveUser(user);
    }
}

 

 

//

redis 的测试

package com.tuy.redis;

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.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;
import java.util.Set;


@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public  void test()
    {
        //字符串  string
        redisTemplate.opsForValue().set("str","hma");
        //redisTemplate.boundValueOps("set").set("hahh");
        System.out.println("str= "+redisTemplate.opsForValue().get("str"));

        //散列 hash
        redisTemplate.boundHashOps("h_key").put("name","tutu");
        redisTemplate.boundHashOps("h_key").put("age","122");
         //获取所有域
        Set h_key_set = redisTemplate.boundHashOps("h_key").keys();
        System.out.println("h_key 域= "+h_key_set);
        //获取所有值
        List h_key_list = redisTemplate.boundHashOps("h_key").values();
        System.out.println("h_key 域的值= "+h_key_list);

        //列表  list
        redisTemplate.boundListOps("1_key").leftPush("o");
        redisTemplate.boundListOps("1_key").leftPush("b");
        redisTemplate.boundListOps("1_key").leftPush("d");
        //获取全部元素
        List list=  redisTemplate.boundListOps("1_key").range(0,-1);
        System.out.println("list列表的所有元素 "+list);

        //集合  set
        redisTemplate.boundSetOps("s_key").add("d","f","e");
        Set s_key = redisTemplate.boundSetOps("s_key").members();
        System.out.println("set集合的所有元素 "+s_key);

        //有序集合  sorted set
        redisTemplate.boundZSetOps("z_key").add("a",30);
        redisTemplate.boundZSetOps("z_key").add("b",20);
        Set z_key = redisTemplate.boundZSetOps("z_key").range(0, -1);
        System.out.println("sortedset集合的所有元素 "+z_key);
    }



}