springBoot学习笔记

最新推荐文章于 2022-01-14 10:25:12 发布

smgk-seven

最新推荐文章于 2022-01-14 10:25:12 发布

阅读量288

点赞数

本文链接：https://blog.csdn.net/weixin_40071332/article/details/84853035

版权

springboot理论知识

1.注解含义

@Configuration：注解中是包含@Component注解的，被@Configuration修饰的类被定义为一个Spring容器（应用上下文）

@Configuration就相当于Spring配置文件中的<beans />标签，里面可以配置bean

@Bean：标注在方法上(返回某个实例的方法)，等价于spring的xml配置文件中的< bean>，作用为：注册bean对象。

新建一个springboot项目

1.在idea中直接建立springboot 项目

2.配置项目

2.1 aplication.properties文件（系统核心配置文件）

#环境配置
#端口
server.port = 8088
#项目根路径
server.context-path = /demofirst

2.2 配置 pom.xml文件（maven配置文件，项目环境）

<?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>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.21.RELEASE</version>
        <relativePath/>
    </parent>
    <groupId>com.smgk</groupId>
    <artifactId>demofirst</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demofirst</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

3.项目程序控制器，DemoFirstApplication

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;
@SpringBootApplication
public class DemofirstApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemofirstApplication.class, args);
    }
}

4. controller层的处理，输入第一个hello

@Controller
public class TestController {
    @RequestMapping("hello")
    @ResponseBody
    public String testHello(){
        return "helloWorld";
    }

}

到此为止在流程器输入 http://localhost:8088/demofirst/hello 即可预览

5.springboot 与mybatis整合（mybatis--> pageHelp -->generator-->mysql-->数据源）

5.1 引入依赖包 pom.xml

   <!-- 引入 thymeleaf 模板依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <!-- 引入log4j日志依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j</artifactId>
            <version>1.3.8.RELEASE</version>
        </dependency>
        <!-- 阿里数据源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.0</version>
        </dependency>
		<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <!--mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>RELEASE</version>
        </dependency>
        <!--tk mybatis,简化mapper层和mapper.xml文件 -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>RELEASE</version>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>4.0.3</version>
        </dependency>
		<!--分布插件-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>RELEASE</version>
        </dependency>
		<!-- generator 逆向生成-->
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.2</version>
            <scope>compile</scope>
            <optional>true</optional>
        </dependency>

5.2 配置项目数据源配置文件application.properties

#配置数据源相关使用阿里巴巴的 druid 数据源
spring.datasource.url=jdbc:mysql://localhost:3306/demofirst
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
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 配置
mybatis.type-aliases-package = com.smgk.demofirst.pojo
mybatis.mapper-locations=classpath:mappers/*.xml
# 配置mybatis工具
mapper.mappers=com.smgk.demofirst.utils.MyMapper
mapper.not-empty=false
mapper.identity=MYSQL
# 分页插件配置
pagehelper.helperDialect=mysql
pagehelper.reasonable=true
pagehelper.supportMethodsArguments=true
pagehelper.params=count=countSql

5.3配置逆向生成的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>
    <context id="MysqlContext" targetRuntime="MyBatis3Simple" defaultModelType="flat">
        <property name="beginningDelimiter" value="`"/>
        <property name="endingDelimiter" value="`"/>

        <plugin type="tk.mybatis.mapper.generator.MapperPlugin">
            <property name="mappers" value="com.smgk.demofirst.utils.MyMapper"/>
        </plugin>
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/demofirst"
                        userId="root"
                        password="123456">
        </jdbcConnection>
        <!-- 对于生成的pojo所在包 -->
        <javaModelGenerator targetPackage="com.smgk.demofirst.pojo" targetProject="src/main/java"/>
		<!-- 对于生成的mapper所在目录 -->
        <sqlMapGenerator targetPackage="mapper" targetProject="src/main/resources"/>
		<!-- 配置mapper对应的java映射 -->
        <javaClientGenerator targetPackage="com.smgk.demofirst.dao" targetProject="src/main/java"
                             type="XMLMAPPER"/>
		<table tableName="STUDENT"></table>
    </context>
</generatorConfiguration>

5.4 使用tk.mybatis要配置的一个本地工具类 MyMapper.java

import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.common.MySqlMapper;
/**
 * 继承自己的MyMapper
 * @author liuzh
 * @since 2015-09-06 21:53
 */
public interface MyMapper<T> extends Mapper<T>, MySqlMapper<T> {
    //TODO
    //FIXME 特别注意，该接口不能被扫描到，否则会出错
}

5.5 进行逆向工程的工作类 GeneratorDisplay.java

配置完成后直接运行些类进可进行逆向生成，执行成功后，dao层和mappers、pojo层会有相对应的文件


import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;
public class GeneratorDisplay {
	public void generator() throws Exception{
		List<String> warnings = new ArrayList<String>();
		boolean overwrite = true;
		//指定 逆向工程配置文件
		File configFile = new File("generatorConfig.xml"); 
		ConfigurationParser cp = new ConfigurationParser(warnings);
		Configuration config = cp.parseConfiguration(configFile);
		DefaultShellCallback callback = new DefaultShellCallback(overwrite);
		MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
				callback, warnings);
		myBatisGenerator.generate(null);

	} 
	public static void main(String[] args) throws Exception {
		try {
			GeneratorDisplay generatorSqlmap = new GeneratorDisplay();
			generatorSqlmap.generator();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

5.6 查询数据库数据

5.6.1 dao层

import com.smgk.demofirst.pojo.Student;
import com.smgk.demofirst.utils.MyMapper;
public interface StudentMapper extends MyMapper<Student> {
}

5.6.2 serv 层

import com.smgk.demofirst.pojo.Student;
import java.util.List;
public interface StudentService {
    public List<Student> queryAllStu();
}

5.6.3 servimp层

这里有个小问题 https://www.jianshu.com/p/54f804abc634

import com.smgk.demofirst.dao.StudentMapper;
import com.smgk.demofirst.pojo.Student;
import com.smgk.demofirst.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class StudentServiceImpl implements StudentService {
    @Autowired
    private StudentMapper studentMapper;
    @Override
    public List<Student> queryAllStu() {
        return studentMapper.selectAll();
    }
}

5.6.4 controller层：

@Controller
public class StudentController {

    @Autowired
    private StudentService studentService;

    @RequestMapping("/queryAllStudent")
    @ResponseBody
    public Msg queryAllStudent(){
        List<Student> students = studentService.queryAllStu();
        return Msg.success().add("success",students);
    }

5.6.5 在DemoFirstApplication类加上注解一定要

@MapperScan(basePackages = "com.smgk.demofirst.dao")

然后浏览看效果http://localhost:8088/demofirst/queryAllStudent

5.7 springboot 访问html 通过ajax请求后台数据

5.7.1 加入依赖

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

5.7.1 配置视图管理在项目配置文件加入

#配置mvcy视图管理器
spring.mvc.view.prefix = /templates/
spring.mvc.view.suffix = .html
spring.mvc.static-path-pattern: /static/**
spring.resources.static-locations: classpath:/static/

5.7.3 前端页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8" />
    <title>Title</title>
    <script type="text/javascript" src="./static/js/jquery-1.12.4.min.js"></script>
</head>
<body>
    <h1> demofirst home </h1>
    <h1> demofisdfasfassfadsfsdafasfrst home </h1>
</body>
</html>
<script>
    $.ajax({
        url:"/demofirst/queryAllStudent",
        type:"POST",
        //data:$("#stuAddModel form").serialize(),
        success:function(result){
            console.log(result)
        }
    })
</script>

访问预览 http://localhost:8088/demofirst/home

6.spring boot中的事务

以下信息来处网络：https://www.cnblogs.com/kesimin/p/9546225.html

@Transactional

spring 事务注解

6.1.简单开启事务管理

@EnableTransactionManagement // 启注解事务管理，等同于xml配置方式的 <tx:annotation-driven />

6.2.事务注解详解

默认遇到throw new RuntimeException(“…”);会回滚
需要捕获的throw new Exception(“…”);不会回滚

指定回滚

@Transactional(rollbackFor=Exception.class) 
    public void methodName() {
       // 不会回滚
       throw new Exception("...");
    }

指定不回滚

@Transactional(noRollbackFor=Exception.class)
    public ItimDaoImpl getItemDaoImpl() {
        // 会回滚
        throw new RuntimeException("注释");
    }

如果有事务,那么加入事务,没有的话新建一个(不写的情况下)

@Transactional(propagation=Propagation.REQUIRED)

容器不为这个方法开启事务

@Transactional(propagation=Propagation.NOT_SUPPORTED)

readOnly=true只读,不能更新,删除

@Transactional (propagation = Propagation.REQUIRED,readOnly=true)

设置超时时间

@Transactional (propagation = Propagation.REQUIRED,timeout=30)

设置数据库隔离级别

@Transactional (propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT)

6.3.指定事务管理器

spring Boot 使用事务非常简单，首先使用注解 @EnableTransactionManagement 开启事务支持后，然后在访问数据库的Service方法上添加注解 @Transactional 便可。

关于事务管理器，不管是JPA还是JDBC等都实现自接口 PlatformTransactionManager 如果你添加的是 spring-boot-starter-jdbc 依赖，框架会默认注入 DataSourceTransactionManager 实例。如果你添加的是 spring-boot-starter-data-jpa 依赖，框架会默认注入 JpaTransactionManager 实例。

你可以在启动类中添加如下方法，Debug测试，就能知道自动注入的是 PlatformTransactionManager 接口的哪个实现类。

7.springboot结合redis使用缓存

7.1引入依赖maven包

        <dependency>
           <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.8.7.RELEASE</version>
        </dependency>

7.2 配置redis

# Redis数据库索引（默认为0）
spring.redis.database=1
# Redis\u670d\u52a1\u5668\u5730\u5740
spring.redis.host=192.168.139.129
# Redis\u670d\u52a1\u5668\u8fde\u63a5\u7aef\u53e3
spring.redis.port=6379
# Redis\u670d\u52a1\u5668\u8fde\u63a5\u5bc6\u7801\uff08\u9ed8\u8ba4\u4e3a\u7a7a\uff09
spring.redis.password=
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=1000
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=2
# 连接超时时间（毫秒）
spring.redis.timeout=0

7.3 引入redis设置缓存，和取缓存数据 java

@Autowired
    private StringRedisTemplate strRedis;

    @Autowired
    private StudentService studentService;

    //如扣操作对象存入redis，最好使用这个存储操作对象
    @Autowired
    private RedisOperator redis;
    /**
     * strRedis.opsForValue().get("test-firstRedis")
     * 通过key 获取 redis的内容
     * @return
     */
    @RequestMapping("/test")
    public Msg test() {
        strRedis.opsForValue().set("test-firstRedis", "hello StringRedisTemplate~~~~~~");
        return Msg.success().add("str",strRedis.opsForValue().get("test-firstRedis"));
    }

    @RequestMapping("/setStu")
    public Msg setStu(){
        Student stu = StuUtils.returnStu();
        String key = "json:user:" + stu.getId();
        redis.set(key, JsonUtils.objectToJson(stu), 2000);

        String stuJson = redis.get(key);
        Student student = JsonUtils.jsonToPojo(stuJson, Student.class);
        return Msg.success().add("succObj",student);
    }
    @RequestMapping("/setStus")
    public Msg setStus(){
        List<Student> students = studentService.queryAllStu();
        String key = "json:stus:allStu";
        redis.set(key, JsonUtils.objectToJson(students), 2000);
        return Msg.success().add("succObj",redis.get("json:stus:allStu"));
    }

8.springboot中使用定时任务（定时调用类）

使用：

8.1 直接在组件类：@component 中的方法写取编写定时任务类/方法

@Component
public class TimeController {
    //日志
    private static final Logger logger = LoggerFactory.getLogger(TimeController.class);
    @Scheduled(fixedRate = 1000)
    public void test(){
        logger.info("------this Timming -------");
    }
}

8.2 入口程序类加入注解 @EnableScheduling

启用即可自动实现

注意

从上面的代码可以看出：@Scheduled有三个属性，分别是：cron expression，fixedDelay，fixedRate （cron，fixdDelay，fixedRate三个属性必须设置一个）

cron:指定的分钟，小时，月，月和日触发。

fixedDelay:在上次调用结束和下一次调用的开始之间以毫秒为单位执行注释方法。

fixedRate:在调用之间以毫秒为单位的固定周期执行带注释的方法。

具本请留意文章：https://www.cnblogs.com/cyrfr/p/9165591.html

9.springboot中的拦截器

使用

9.1 引入AOP包

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

9.2在入口类加入 @EnableScheduling

9.3设置需要拦截的controller

@RestController
@RequestMapping("/stuInterController")
public class StuInterController {
    @Autowired
    private StudentService studentService;

    @RequestMapping(value = "/getStuById/{id}")
    public Msg getStuById(@PathVariable("id") int id){
        Student stuById = studentService.getStuById(id);
        return Msg.success().add("Stu", stuById);
    }
}

9.4 编写监听程序

public class StuInterceptor implements HandlerInterceptor {
    private static Logger logger = LoggerFactory.getLogger(StuInterceptor.class);
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        logger.debug("----执行前");
        System.out.println("----执行前");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
            throws Exception {
        logger.debug("----执行后");
        System.out.println("----执行后");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        logger.debug("----执行结束");
        System.out.println("----执行结束");
    }
}

9.5注册监听器，设置拦截路径，在配置类处理，

@Configuration
public class InterceptorConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //registry.addInterceptor(new OneInterceptor()).addPathPatterns("/interceptor/one");
        registry.addInterceptor(new StuInterceptor()).addPathPatterns("/stuInterController/getStuById/*");
        super.addInterceptors(registry);
    }
}

10.spring boot中使用接口/提供、调用

10.1 提供一个webServ接口

10.1.1 引入包，

        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-spring-boot-starter-jaxws</artifactId>
            <version>3.2.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxws</artifactId>
            <version>3.1.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-transports-http</artifactId>
            <version>3.1.6</version>
        </dependency>

10.1.2 编号webServ接口

package com.smgk.login.service;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
@WebService
public interface  HelloWebService {

    @WebMethod
    public String Hello(@WebParam(name="name") String name);
}

10.1.3 编写webServ接口实现类

package com.smgk.login.service.impl;
import com.smgk.login.service.HelloWebService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import javax.jws.WebParam;
import javax.jws.WebService;
@WebService(
        targetNamespace="http://service.login.smgk.com/",//命名空间，接口包的反包名
        serviceName = "HelloWebService",//接口名称
        endpointInterface = "com.smgk.login.service.HelloWebService")//接口包
@Configuration
public class HelloWebServiceImpl implements HelloWebService {
    Logger logger = LoggerFactory.getLogger(HelloWebServiceImpl.class);

    @Override
    public String Hello(@WebParam(name = "name") String name) {
        System.out.println();
        logger.info("------接口调用-------"+ name + "sayHello");
        System.out.println();
        return name + "sayHello";
    }
}

10.1.4编写接口配置

package com.smgk.login.config;
import com.smgk.login.service.HelloWebService;
import org.apache.cxf.Bus;
import javax.xml.ws.Endpoint;
import org.apache.cxf.jaxws.EndpointImpl;
import org.apache.cxf.transport.servlet.CXFServlet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class WebServiceConfig {

    @Autowired
    private Bus bus;

    @Autowired
    private HelloWebService helloWebService;

    @Bean("cxfServletRegistration")
    public ServletRegistrationBean dispatcherServlet() {
        //注册servlet 拦截/ws 开头的请求 不设置 默认为：/services/*
        return new ServletRegistrationBean(new CXFServlet(), "/ws/*");
    }

    @Bean
    public Endpoint endpoint() {
        EndpointImpl endpoint = new EndpointImpl(bus, helloWebService);
        endpoint.publish("/helloWebService");//发布地址
        return endpoint;
    }

}

10.2客户端调用

public void add(){
        JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();
        Client client = dcf.createClient("http://127.0.0.1:8081/login/ws/helloWebService?wsdl");
        // 需要密码的情况需要加上用户名和密码
        // client.getOutInterceptors().add(new ClientLoginInterceptor(USER_NAME, PASS_WORD));
        Object[] objects = new Object[0];
        try {
            // invoke("方法名",参数1,参数2,参数3....);
            objects = client.invoke("Hello", "maple");
            System.out.println("返回数据:" + objects[0]);
        } catch (java.lang.Exception e) {
            e.printStackTrace();
        }
    }