springboot笔记

原理

普通实现

集成

mybatis

添加依赖

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

自动生成数据库匹配文件

mybatis-generator插件

            <plugin>
              <groupId>org.mybatis.generator</groupId>
              <artifactId>mybatis-generator-maven-plugin</artifactId>
              <version>1.4.0</version>
            </plugin>

添加generatorConfig.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>
  <classPathEntry location="/Users/jianghuilai/Library/Application Support/JetBrains/IntelliJIdea2020.1/jdbc-drivers/MySQL Connector/J 8/8.0.21/mysql-connector-java-8.0.21.jar" />

  <context id="DB2Tables" targetRuntime="MyBatis3">
    <jdbcConnection driverClass="com.mysql.jdbc.Driver"
        connectionURL="jdbc:mysql://localhost:3306/ex5"
        userId="root"
        password="">
    </jdbcConnection>

    <javaTypeResolver >
      <property name="forceBigDecimals" value="false" />
    </javaTypeResolver>

    <javaModelGenerator targetPackage="com.example.demo3.model" targetProject="/Users/jianghuilai/IdeaProjects/sb-ex/demo3/src/main/java">
      <property name="enableSubPackages" value="true" />
      <property name="trimStrings" value="true" />
    </javaModelGenerator>

    <sqlMapGenerator targetPackage="com.example.demo3.mapper"  targetProject="/Users/jianghuilai/IdeaProjects/sb-ex/demo3/src/main/java">
      <property name="enableSubPackages" value="true" />
    </sqlMapGenerator>

    <javaClientGenerator type="XMLMAPPER" targetPackage="com.example.demo3.mapper"  targetProject="/Users/jianghuilai/IdeaProjects/sb-ex/demo3/src/main/java">
      <property name="enableSubPackages" value="true" />
    </javaClientGenerator>

    <table schema="ex5" tableName="student">
<!--      <property name="useActualColumnNames" value="true"/>-->
      <generatedKey column="id" sqlStatement="Mysql" identity="true" />
    </table>

  </context>
</generatorConfiguration>

这里面三个generator标签javaModelGenerator，sqlMapGenerator，javaClientGenerator
都有共同属性：targetPackage就是文件上面的package
里面的属性有enableSubPackages，如果是true，那么文件就会被放到targetProject+targetPackage的路径下
javaModelGenerator是生成model文件的
sqlMapGenerator是生成mapper.xml的
javaClientGenerator是生成mapper接口的
当然不要这样子写，最好把sqlMapGenerator放到resources文件夹下，不然我们还要在pom.xml中添加resources属性了
++++++++++++++++++++++++++++++++++++++++++++++++++
table标签当然就是我们需要映射的表
schema就是数据库名字，可以没有，因为我们的jdbcConnection里面表明了数据库
tableName就是必须的了，跟数据库的表明保持一致
默认生成的java对象的属性名是user_name=>userName，就是以_为区分的小驼峰形式

然后我们会得到相应的mapper，model，和mapper.xml文件
我们要给mapper接口添加@Mapper注解，这样子会将mapper文件以bean的形式添加到spring容器中
我们也可以在springboot主运行程序添加@MapperScan注解，得到所有的mapper接口
然后我们添加service和controller
然后在application.yml中添加连接数据库的信息：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/ex5
    username: root
    password:
    driver-class-name: com.mysql.cj.jdbc.Driver

Redis

添加依赖：

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.3.4.RELEASE</version>
        </dependency>

配置一下redis：

server:
  port: 9527

spring:
  redis:
    url: redis://localhost:6379

redis的主要使用对象就是RedisTemplate，使用方法如下：

    @Autowired
    private RedisTemplate<Object, Object> template;

    @Override
    public Integer add(String key, String value) {
        ValueOperations<Object, Object> ops = template.opsForValue();
        ops.set(key, value);
        return 1;
    }

dubbo

dubbo配合zookeeper

macOS不要用brew下载zookeeper，会启动不了的。还是去官网下载吧

创建三个module：

• interface
• provider
• consumer

在interface中添加服务接口

Provider和Consumer中添加依赖：

<!--		服务接口依赖-->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>db-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
		
<!--		dubbo依赖-->
		<!-- https://mvnrepository.com/artifact/org.apache.dubbo/dubbo-spring-boot-starter -->
		<dependency>
		    <groupId>org.apache.dubbo</groupId>
		    <artifactId>dubbo-spring-boot-starter</artifactId>
		    <version>2.7.8</version>
		</dependency>

<!--		zookeeper依赖-->
		<!-- https://mvnrepository.com/artifact/com.101tec/zkclient -->
		<dependency>
		    <groupId>com.101tec</groupId>
		    <artifactId>zkclient</artifactId>
		    <version>0.11</version>
		</dependency>
		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-recipes</artifactId>
			<version>5.1.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<version>3.5.8</version>
		</dependency>

Provider：
配置一下application.yml：

server:
  port: 9527
  servlet:
    context-path: /
dubbo:
  application:
    name: db-provider
  registry:
    address: zookeeper://127.0.0.1:2181
    protocol: zookeeper

添加服务

@Component
@DubboService(interfaceClass = StduentService.class, version = "1.1.1", timeout = 9999)
public class StduentServiceImpl implements StduentService {
    @Override
    public int count() {
        return 1024;
    }
}

通过@Component放入spring容器
通过@DubboService表明这个是dubbo服务

在主启动文件上添加一下注解

@EnableDubboConfig
@DubboComponentScan("com.example.dbprovider.service")

通过@EnableDubboConfig来启动yml文件中的配置
通过@DubboComponentScan("com.example.dbprovider.service")来发现dubbo服务，并且放入到注册中心

Consumer：
配置一下application.yml：

server:
  port: 9528
  servlet:
    context-path: /
dubbo:
  application:
    name: db-consumer
  registry:
    address: zookeeper://localhost:2181
    protocol: zookeeper

添加controller，调用服务：

@RestController
public class StudentController {
    @DubboReference(interfaceClass = StduentService.class,version = "1.1.1")
    private StduentService service;

    @RequestMapping("/count")
    int query(){
        return service.count();
    }

}

这里@RestController就是类似于@Controller，并且在每个方法上都添加了@ResponseBody，也就是每个方法返回的都是Object
@DubboReference(interfaceClass = StduentService.class,version = "1.1.1")引用了服务，可以有属性check=true，如果为false，那么就是懒加载，就不会在一开始启动的时候就检查服务是否加载成功，在调用的时候才会加载服务

然后在主文件添加：

@EnableDubboConfig

激活dubbo配置，以读取yml文件中的dubbo配置

dubbo-ssm

就是把上面的都整合到一起，没啥好说的，但还是说一下
创建三个模块：

• interface
• provider
• consumer
  Provider，interface：
  给Provider添加依赖：

        <!--		dubbo-->
        <!-- https://mvnrepository.com/artifact/org.apache.dubbo/dubbo-spring-boot-starter -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.8</version>
        </dependency>

        <!--		zookeeper-->
        <!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.6.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>5.1.0</version>
        </dependency>


        <!--		mybatis-->
        <!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <!--		mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--		Redis-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.3.4.RELEASE</version>
        </dependency>

        <!--		接口-->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>dbsm-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

添加mybatis generator插件：

            <!--		mybatis自动生成-->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.4.0</version>
            </plugin>

将model放到interface模块下
mapper放到Provider模块下
歪日，在使用generator的时候出现了找不到接口依赖的POM文件，查了说了clean一下就好了，但是我不行，然后我自己的解决方法是把接口module也install一下就行了，但是前几天还是不需要install的，👴真的懵了，以后学好了再去看看文档吧。
老师说是这个generator会从本地仓库去找需要的包，所以我们需要install，然后他才会出现在本地仓库里。
不过我还是不知道为什么我之前可以不install。

给interface的model实现Serializable
Provider的配置文件application.yml:

server:
  port: 9527

dubbo:
  application:
    name: provider
  registry:
    address: zookeeper://localhost:2181
mybatis:
  mapper-locations: classpath:mapper/*.xml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ex5
    username: root

Provider给服务添加@DubboService注解，给主文件添加@MapperScan，@DubboConfig，@DubboComponentScan

Consumer：
而Consumer只需要添加dubbo，curator，和接口依赖就行了
然后给controller里加上引用@DubboReference

springboot-java模块

如何得到我们的@Service的bean
springboot启动会创建一个ConfigurableApplicationContext，就是一种spring容器对象，我们可以通过这个对象来getBean获取我们创建的bean
这个对象在主启动文件的SpringApplication.run(DemoApplication.class, args);中返回：

		ConfigurableApplicationContext context = SpringApplication.run(DemoApplication.class, args);
		MyService service = context.getBean("myService");

也可以通过实现CommandLineRunner接口，里面的run方法就会在启动后调用：

public class DemoApplication implements CommandLineRunner {

	@Autowired
	private StudentServiceImpl service;
	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}

	@Override
	public void run(String... args) throws Exception {
		service.sayHello("Hello");
	}
}

使用interceptor

写个interceptor类，实现HandlerInterceptor
写个configuration：

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor());
    }
}

使用servlet

方法一

创建一个servlet，继承HttpServlet
添加注解@WebServlet，通过urlpatterns表示路径
在启动程序上添加@ServletComponentScan，因为他是servlet提供的，不是spring的，@SpringBootApplication只会扫描spring容器而已

方法二

创建一个servlet，继承HttpServlet
创建一个configuration类，添加注解@Configuration
在类中添加@Bean注解的方法，方法中返回一个ServletRegistrationBean，因为已经添加到spring容器中了，所以不用添加@ServletComponentScan

@Configuration
public class ServeltConfig {
    @Bean
    public ServletRegistrationBean<MyServlet> servletRegistrationBean(){
        ServletRegistrationBean<MyServlet> moli = new ServletRegistrationBean<>(new MyServlet(), "/moli");
        return moli;
    }
}

filter

方法一

创建一个filter类，实现Filter接口，是servlet包里的filter
添加上@WebFilter注解
覆盖方法
在启动程序上加上@ComponentScan注解

方法二

同servlet，添加配置文件@Configuration
实现方法:

@Configuration
public class ServeltConfig {
    @Bean
    public FilterRegistrationBean<Filter> filterRegistrationBean(){
        return new FilterRegistrationBean<>(new MyFilter());
    }
}

打包部署

war

在pom.xml中修改：

    <packaging>war</packaging>
    ...
    ...
    <build>
        <finalName>sb-ex-war</finalName>
        ...
        ...
    </build>

因为是springboot项目，注意还要让启动程序继承SpringBootServletInitializer

@SpringBootApplication
@EnableDubboConfig
@DubboComponentScan("com.example.sbexconsumer.Service")
@MapperScan("com.example.sbexconsumer.mapper")
public class SbExConsumerApplication extends SpringBootServletInitializer {

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

}

然后mvn clean package就会出来一个war包
我们可以吧war包放到Tomcat目录下的Webapp目录下，然后启动Tomcat，{tomcatpath}/catalina.sh start，就能在{tomcatwebpath}/sb-ex-war下访问到了
之前我们在application.properties里面设置的端口号就失效了，以Tomcat的为准

jar

打个jar包就相对简单很多了，package标签默认就是jar，最好指定下fileName，然后mvn clean package，就可以在target目录下找到相应的jar包了，然后在命令行java -jar {filepath}就可以直接运行了
运行时没有依赖我们本地的Tomcat服务器，所以端口当然还是在application.properties里指定的那个端口

logging

logback

在springboot里面的logging还是比较简单的。只要有spring boot web starter，就会有log依赖。
我们只要在resources目录下创建logback-spring.xml或者logback.xml，就可以使用更多的log。

如果报错说你多了一些logger的话，我们可以通过idea自带的maven -> show dependencies，在右边侧栏里。把不需要的依赖给删掉

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
    <include resource="org/springframework/boot/logging/logback/console-appender.xml" />
    <include resource="org/springframework/boot/logging/logback/file-appender.xml" />
    <root level="INFO">
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="FILE" />
    </root>
    <logger name="com.example.sbexconsumer.mapper" level="DEBUG"/>
</configuration>

当然我们也可以自定义一下appender，具体怎么做就参考一下这些引用的文件和官方文档呗
这里我们导入了defaults.xml,console-appender.xml，file-appender.xml，第一个是一些配置，后面两个是appender。通过appender-ref引用了后面两个。
我们通过<logger name="com.example.sbexconsumer.mapper" level="DEBUG"/>表示我们mapper下的文件要以debug级别去log。其他的都是默认的级别，在defaults.xml里面有定义。

当然由于使用了file-appender。我们还要在application.properties中定义一下logging,file.name或logging.file.path
file name是文件名，file path是文件路径。file path是相对路径，相对于Project，默认是/，file name是在file path下的
所以结果的文件是{project-path}/{file-path}/{file-name}

各个日志级别：
ALL < DEBUG < INFO < WARN < ERROR < FATAL < OFF
在这里设置的level=DEBUG，表示大于等于DEBUG的事件，都会被输出