关于java:万字长文史上最全的SpringBoot学习笔记

能源节点王鹤老师的 SpringBoot 入门系列课程，通俗易懂，基于 SpringBoot2.4 版本解说。

从细节动手，每个事例先解说 pom.xml 中的重要依赖，其次 application 配置文件，最初是代码实现。让你知其所以，逐渐让把握 SpringBoot 框架的主动配置，starter 起步依赖等个性。

视频资源

https://www.bilibili.com/video/BV1XQ4y1m7ex

为什么要应用 Spring Boot

因为 Spring，SpringMVC 须要应用的大量的配置文件（xml 文件）

还须要配置各种对象，把应用的对象放入到 spring 容器中能力应用对象

须要理解其余框架配置规定。
SpringBoot 就相当于不须要配置文件的 Spring+SpringMVC。罕用的框架和第三方库都曾经配置好了。

拿来就能够应用了。
SpringBoot 开发效率高，使用方便多了

JavaConfig: 应用 java 类作为 xml 配置文件的代替，是配置 spring 容器的纯 java 的形式。在这个 java 类这能够创立 java 对象，把对象放入 spring 容器中（注入到容器），

应用两个注解：

1）@Configuration：放在一个类的下面，示意这个类是作为配置文件应用的。

2）@Bean：申明对象，把对象注入到容器中。

 例子：package com.bjpowernode.config;

import com.bjpowernode.vo.Student;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Configuration: 示意以后类是作为配置文件应用的。就是用来配置容器的
 *       地位：在类的下面
 *
 *  SpringConfig 这个类就相当于 beans.xml
 */
@Configuration
public class SpringConfig {

    /**
     * 创立办法，办法的返回值是对象。在办法的下面退出 @Bean
     * 办法的返回值对象就注入到容器中。*
     * @Bean: 把对象注入到 spring 容器中。作用相当于 <bean>
     *
     *     地位：办法的下面
     *
     *     阐明：@Bean, 不指定对象的名称，默认是办法名是 id
     *
     */
    @Bean
    public Student createStudent(){Student s1  = new Student();
        s1.setName("张三");
        s1.setAge(26);
        s1.setSex("男");
        return s1;
    }


    /***
     * 指定对象在容器中的名称（指定 <bean> 的 id 属性）* @Bean 的 name 属性，指定对象的名称（id）*/
    @Bean(name = "lisiStudent")
    public Student makeStudent(){Student s2  = new Student();
        s2.setName("李四");
        s2.setAge(22);
        s2.setSex("男");
        return s2;
    }
}

@ImportResource 作用导入其余的 xml 配置文件，等于在 xml

<import resources="其余配置文件"/>

例如：

@Configuration
@ImportResource(value ={ "classpath:applicationContext.xml","classpath:beans.xml"})
public class SpringConfig {}

@PropertyResource: 读取 properties 属性配置文件。应用属性配置文件能够实现内部化配置，

在程序代码之外提供数据。

步骤：

在 resources 目录下，创立 properties 文件，应用 k = v 的格局提供数据
在 PropertyResource 指定 properties 文件的地位
应用 @Value（value=”${key}”）

@Configuration
@ImportResource(value ={ "classpath:applicationContext.xml","classpath:beans.xml"})
@PropertySource(value = "classpath:config.properties")
@ComponentScan(basePackages = "com.bjpowernode.vo")
public class SpringConfig {}

SpringBoot 是 Spring 中的一个成员，能够简化 Spring，SpringMVC 的应用。他的外围还是 IOC 容器。

特点：

Create stand-alone Spring applications

创立 spring 利用

Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)

内嵌的 tomcat，jetty，Undertow

Provide opinionated ‘starter’ dependencies to simplify your build configuration

提供了 starter 起步依赖，简化利用的配置。

比方应用 MyBatis 框架，须要在 Spring 我的项目中，配置 MyBatis 的对象 SqlSessionFactory，Dao 的代理对象

在 SpringBoot 我的项目中，在 pom.xml 外面, 退出一个 mybatis-spring-boot-starter 依赖

Automatically configure Spring and 3rd party libraries whenever possible

尽可能去配置 spring 和第三方库。叫做主动配置（就是把 spring 中的，第三方库中的对象都创立好，放到容器中，开发人员能够间接应用）

Provide production-ready features such as metrics, health checks, and externalized configuration

提供了健康检查，统计，内部化配置

Absolutely no code generation and no requirement for XML configuration

不必生成代码，不必应用 xml，做配置

应用的地址：https://start.spring.io

SpringBoot 我的项目的构造：

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传 (img-dRfOaTEk-1645599534519)(D:\course\25-SpringBoot\ 笔记 \images\image-20210115152427829.png)]

https://start.springboot.io

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传 (img-IN52drB7-1645599534520)(D:\course\25-SpringBoot\ 笔记 \images\image-20210115155556662.png)]

@SpringBootApplication
合乎注解：由
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
    
    
1.@SpringBootConfiguration
    
@Configuration
public @interface SpringBootConfiguration {
    @AliasFor(annotation = Configuration.class)
    boolean proxyBeanMethods() default true;}

阐明：应用了 @SpringBootConfiguration 注解标注的类，能够作为配置文件应用的，能够应用 Bean 申明对象，注入到容器

2.@EnableAutoConfiguration

启用主动配置，把 java 对象配置好，注入到 spring 容器中。例如能够把 mybatis 的对象创立好，放入到容器中

3.@ComponentScan

@ComponentScan 扫描器，找到注解，依据注解的性能创建对象，给属性赋值等等。默认扫描的包：@ComponentScan 所在的类所在的包和子包。

配置文件名称：application

扩展名有：properties(k=v) ; yml (k: v)

应用 application.properties, application.yml

例 1：application.properties 设置端口和上下文

# 设置端口号
server.port=8082
#设置拜访利用上下文门路，contextpath
server.servlet.context-path=/myboot

例 2：application.yml

server:
  port: 8083
  servlet:
    context-path: /myboot2

有开发环境，测试环境，上线的环境。

每个环境有不同的配置信息，例如端口，高低文件，数据库 url，用户名，明码等等

应用多环境配置文件，能够不便的切换不同的配置。

应用形式：创立多个配置文件，名称规定：application- 环境名称.properties(yml)

创立开发环境的配置文件：application-dev.properties(application-dev.yml)

创立测试者应用的配置：application-test.properties

@ConfigurationProperties: 把配置文件的数据映射为 java 对象。

属性：prefix 配置文件中的某些 key 的结尾的内容。


@Component
@ConfigurationProperties(prefix = "school")
public class SchoolInfo {

    private String name;

    private String website;

    private String address;


    public String getName() {return name;}

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

    public String getWebsite() {return website;}

    public void setWebsite(String website) {this.website = website;}

    public String getAddress() {return address;}

    public void setAddress(String address) {this.address = address;}

    @Override
    public String toString() {
        return "SchoolInfo{" +
                "name='" + name + '\'' +
                ", website='" + website + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

application.properties

# 配置端口号
server.port=8082
#context-path
server.servlet.context-path=/myboot

#自定义 key=value
school.name= 能源节点
school.website=www.bjpowernode.com
school.address= 北京的大兴区

site=www.bjpowernode.com

SpringBoot 不举荐应用 jsp，而是应用模板技术代替 jsp

应用 jsp 须要配置：

1）退出一个解决 jsp 的依赖。负责编译 jsp 文件

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

2) 如果须要应用 servlet，jsp，jstl 的性能

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
</dependency>

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
</dependency>

<dependency>
<groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.3.1</version>
</dependency>

3) 创立一个寄存 jsp 的目录，个别叫做 webapp

index.jsp

4) 须要在 pom.xml 指定 jsp 文件编译后的寄存目录。

META-INF/resources

5）创立 Controller，拜访 jsp

6）在 application.propertis 文件中配置视图解析器

你想通过代码，从容器中获取对象。

通过 SpringApplication.run(Application.class, args); 返回值获取容器。


public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {return run(new Class[]{primarySource}, args);
}

ConfigurableApplicationContext : 接口，是 ApplicationContext 的子接口
public interface ConfigurableApplicationContext extends ApplicationContext

这两个接口都有一个 run 办法。执行工夫在容器对象创立好后，主动执行 run（）办法。

能够实现自定义的在容器对象创立好的一些操作。

@FunctionalInterface
public interface CommandLineRunner {void run(String... args) throws Exception;
}

@FunctionalInterface
public interface ApplicationRunner {void run(ApplicationArguments args) throws Exception;
}

讲三个内容：拦截器，Servlet，Filter

拦截器是 SpringMVC 中一种对象，能拦截器对 Controller 的申请。

拦截器框架中有零碎的拦截器，还能够自定义拦截器。实现对申请事后解决。

实现自定义拦截器：

创立类实现 SpringMVC 框架的 HandlerInterceptor 接口

public interface HandlerInterceptor {default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {return true;}

 default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception { }

 default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {}}

2. 需在 SpringMVC 的配置文件中，申明拦截器

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:path="url" />
        <bean class="拦截器类全限定名称"/>
    </mvc:interceptor>
</mvc:interceptors>

SpringBoot 中注册拦截器：


@Configuration
public class MyAppConfig implements WebMvcConfigurer {

    // 增加拦截器对象，注入到容器中
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        // 创立拦截器对象
        HandlerInterceptor interceptor = new LoginInterceptor();

        // 指定拦挡的申请 uri 地址
        String path []= {"/user/**"};
        // 指定不拦挡的地址
        String excludePath  [] = {"/user/login"};
        registry.addInterceptor(interceptor)
                .addPathPatterns(path)
                .excludePathPatterns(excludePath);

    }
}

在 SpringBoot 框架中应用 Servlet 对象。

应用步骤：

创立 Servlet 类。创立类继承 HttpServlet
注册 Servlet，让框架能找到 Servlet

例子：

1. 创立自定义 Servlet

// 创立 Servlet 类
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       // 应用 HttpServletResponse 输入数据，应答后果
        resp.setContentType("text/html;charset=utf-8");
        PrintWriter out  = resp.getWriter();
        out.println("=== 执行的是 Servlet==");
        out.flush();
        out.close();}
}

@Configuration
public class WebApplictionConfig {

    // 定义方法，注册 Servlet 对象
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){//public ServletRegistrationBean(T servlet, String... urlMappings)
        // 第一个参数是 Servlet 对象，第二个是 url 地址

        //ServletRegistrationBean bean =
                //new ServletRegistrationBean(new MyServlet(),"/myservlet");


        ServletRegistrationBean bean = new ServletRegistrationBean();
        bean.setServlet(new MyServlet());
        bean.addUrlMappings("/login","/test"); // <url-pattern>


        return bean;
    }
}

Filter 是 Servlet 标准中的过滤器，能够解决申请，对申请的参数，属性进行调整。经常在过滤器中解决字符编码

在框架中应用过滤器：

创立自定义过滤器类
注册 Filter 过滤器对象

例子：

// 自定义过滤器
public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {System.out.println("执行了 MyFilter，doFilter");
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

@Configuration
public class WebApplicationConfig {

    @Bean
    public FilterRegistrationBean filterRegistrationBean(){FilterRegistrationBean bean  = new FilterRegistrationBean();
        bean.setFilter(new MyFilter());
        bean.addUrlPatterns("/user/*");
        return bean;
    }
}

CharacterEncodingFilter : 解决 post 申请中乱码的问题

在 SpringMVC 框架，在 web.xml 注册过滤器。配置他的属性。

第一种形式：

应用步骤：

配置字符集过滤器

@Configuration
public class WebSystemConfig {

    // 注册 Servlet
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){MyServlet myServlet = new MyServlet();
        ServletRegistrationBean reg = new ServletRegistrationBean(myServlet,"/myservlet");
        return reg;
    }


    // 注册 Filter
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){FilterRegistrationBean reg = new FilterRegistrationBean();

        // 应用框架中的过滤器类
        CharacterEncodingFilter filter  = new CharacterEncodingFilter();
        // 指定应用的编码方式
        filter.setEncoding("utf-8");
        // 指定 request，response 都应用 encoding 的值
        filter.setForceEncoding(true);

        reg.setFilter(filter);
        // 指定 过滤的 url 地址
        reg.addUrlPatterns("/*");


        return reg;
    }
}

批改 application.properties 文件，让自定义的过滤器起作用

#SpringBoot 中默认曾经配置了 CharacterEncodingFilter。编码默认 ISO-8859-1
#设置 enabled=false 作用是关闭系统中配置好的过滤器，应用自定义的 CharacterEncodingFilter
server.servlet.encoding.enabled=false

第二种形式

批改 application.properties 文件

server.port=9001
server.servlet.context-path=/myboot

#让零碎的 CharacterEncdoingFilter 失效
server.servlet.encoding.enabled=true
#指定应用的编码方式
server.servlet.encoding.charset=utf-8
#强制 request，response 都应用 charset 属性的值
server.servlet.encoding.force=true

应用 MyBatis 框架操作数据，在 SpringBoot 框架集成 MyBatis

应用步骤：

mybatis 起步依赖：实现 mybatis 对象主动配置，对象放在容器中
pom.xml 指定把 src/main/java 目录中的 xml 文件蕴含到 classpath 中
创立实体类 Student
创立 Dao 接口 StudentDao , 创立一个查问学生的办法
创立 Dao 接口对应的 Mapper 文件，xml 文件，写 sql 语句
创立 Service 层对象，创立 StudentService 接口和他的实现类。去 dao 对象的办法。实现数据库的操作
创立 Controller 对象，拜访 Service。
写 application.properties 文件

配置数据库的连贯信息。

@Mapper：放在 dao 接口的下面，每个接口都须要应用这个注解。

/**
 * @Mapper：通知 MyBatis 这是 dao 接口，创立此接口的代理对象。*     地位：在类的下面
 */
@Mapper
public interface StudentDao {Student selectById(@Param("stuId") Integer id);
}

/**
 * @MapperScan: 找到 Dao 接口和 Mapper 文件
 *     basePackages：Dao 接口所在的包名
 */
@SpringBootApplication
@MapperScan(basePackages = {"com.bjpowernode.dao","com.bjpowernode.mapper"})
public class Application {}

当初把 Mapper 文件放在 resources 目录下

1）在 resources 目录中创立子目录（自定义的），例如 mapper

2）把 mapper 文件放到 mapper 目录中

3）在 application.properties 文件中，指定 mapper 文件的目录

# 指定 mapper 文件的地位
mybatis.mapper-locations=classpath:mapper/*.xml
#指定 mybatis 的日志
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

4) 在 pom.xml 中指定把 resources 目录中的文件，编译到目标目录中

<!--resources 插件 -->
<resources>
   <resource>
      <directory>src/main/resources</directory>
      <includes>
         <include>**/*.*</include>
      </includes>
   </resource>
</resources>

Spring 框架中的事务：

1）治理事务的对象：事务管理器（接口，接口有很多的实现类）

例如：应用 Jdbc 或 mybatis 拜访数据库，应用的事务管理器：DataSourceTransactionManager

2 ) 申明式事务：在 xml 配置文件或者应用注解阐明事务管制的内容

管制事务：隔离级别，流传行为，超时工夫

3）事务处理形式：

1）Spring 框架中的 @Transactional

2) aspectj 框架能够在 xml 配置文件中，申明事务管制的内容

SpringBoot 中应用事务：下面的两种形式都能够。

1）在业务办法的下面退出 @Transactional , 退出注解后，办法有事务性能了。

2）明确的在主启动类的下面，退出 @EnableTransactionManager

例子：

/**
 * @Transactional: 示意办法的有事务反对
 *       默认：应用库的隔离级别，REQUIRED 流传行为；超时工夫  -1
 *       抛出运行时异样，回滚事务
 */
@Transactional
@Override
public int addStudent(Student student) {System.out.println("业务办法 addStudent");
    int rows  =  studentDao.insert(student);
    System.out.println("执行 sql 语句");

    // 抛出一个运行时异样，目标是回滚事务
    //int m   = 10 / 0 ;

    return rows;
}

接口：API（Application Programming Interface，利用程序接口）是一些事后定义的接口（如函数、HTTP 接口），或指软件系统不同组成部分连接的约定。用来提供应用程序与开发人员基于某软件或硬件得以拜访的一组例程，而又无需拜访源码，或了解外部工作机制的细节。

接口（API）：能够指拜访 servlet，controller 的 url，调用其余程序的函数

架构格调：api 组织形式（样子）

就是一个传统的：http://localhost:9002/mytrans…

在地址上提供了拜访的资源名称 addStudent, 在其后应用了 get 形式传递参数。

RESTful 架构格调

1)REST :（英文：Representational State Transfer , 中文：体现层状态转移 )。

REST：是一种接口的架构格调和设计的理念，不是规范。

长处：更简洁，更有档次

体现层状态转移:

体现层就是视图层，显示资源的，通过视图页面，jsp 等等显示操作资源的后果。

状态：资源变动

转移：资源能够变动的。资源能创立，new 状态，资源创立后能够查问资源，能看到资源的内容，

这个资源内容，能够被批改，批改后资源和之前的不一样。

2）REST 中的因素：

用 REST 示意资源和对资源的操作。在互联网中，示意一个资源或者一个操作。

资源应用 url 示意的，在互联网，应用的图片，视频，文本，网页等等都是资源。

资源是用名词示意。

对资源：

查问资源：看，通过 url 找到资源。

创立资源：增加资源

更新资源：更新资源，编辑

删除资源：去除

资源应用 url 示意，通过名词示意资源。

在 url 中，应用名词示意资源，以及拜访资源的信息, 在 url 中，应用“/ ” 分隔对资源的信息

http://localhost:8080/myboot/…

应用 http 中的动作（申请形式），示意对资源的操作（CURD）

GET: 查问资源 — sql select

解决单个资源：用他的复数形式

http://localhost:8080/myboot/…

解决多个资源：应用复数模式

http://localhost:8080/myboot/…

POST: 创立资源 — sql insert

http://localhost:8080/myboot/…

在 post 申请中传递数据

<form action="http://localhost:8080/myboot/student" method="post">
    姓名：<input type="text" name="name" />
    年龄：<input type="text" name="age" />
  </form>

PUT：更新资源 — sql update

<form action="http://localhost:8080/myboot/student/1" method="post">
 姓名：<input type="text" name="name" />
 年龄：<input type="text" name="age" />
      <input type="hidden" name="_method" value="PUT" />
  </form>

DELETE: 删除资源 — sql delete

<a href="http://localhost:8080/myboot/student/1"> 删除 1 的数据 </a>

须要的分页，排序等参数，仍然放在 url 的前面，例如

http://localhost:8080/myboot/…

3）一句话阐明 REST：

应用 url 示意资源，应用 http 动作操作资源。

4) 注解

@PathVariable : 从 url 中获取数据

@GetMapping: 反对的 get 申请形式，等同于 @RequestMapping(method=RequestMethod.GET)

@PostMapping: 反对 post 申请形式，等同于 @RequestMapping(method=RequestMethod.POST)

@PutMapping: 反对 put 申请形式，等同于 @RequestMapping(method=RequestMethod.PUT)

@DeleteMapping: 反对 delete 申请形式，等同于 @RequestMapping(method=RequestMethod.DELETE)

@RestController: 合乎注解，是 @Controller 和 @ResponseBody 组合。

在类的下面应用 @RestController，示意以后类者的所有办法都退出了 @ResponseBody

5) Postman : 测试工具

应用 Postman : 能够测试 get，post，put，delete 等申请

在 SpringMVC 中有一个过滤器，反对 post 申请转为 put ,delete

过滤器：org.springframework.web.filter.HiddenHttpMethodFilter

作用：把申请中的 post 申请转为 put，delete

实现步骤：

application.properties(yml) : 开启应用 HiddenHttpMethodFilter 过滤器
在申请页面中，蕴含 _method 参数，他的值是 put，delete，发动这个申请应用的 post 形式

Redis：一个 NoSQL 数据库，罕用作缓存应用（cache）

Redis 的数据类型：string , hash ,set ,zset , list

Redis 是一个中间件：是一个独立的服务器。

java 中驰名的客户端：Jedis，lettuce，Redisson

Spring,SpringBoot 中有一个 RedisTemplate（StringRedisTemplate），解决和 redis 交互

Redis-x64-3.2.100.rar 解压缩到一个非中文的目录

redis-server.exe：服务端，启动后，不要敞开

redis-cli.exe：客户端，拜访 redis 中的数据

redisclient-win32.x86_64.2.0.jar : Redis 图形界面客户端

执行形式：在这个文件所在的目录，执行 java -jar redisclient-win32.x86_64.2.0.jar

RedisTemplate 应用的 lettuce 客户端库

<!--redis 起步依赖：间接在我的项目中应用 RedisTemplate(StringRedisTemplate)-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
data-redis 应用的   lettuce 客户端库

在程序中应用 RedisTemplate 类的办法 操作 redis 数据，理论就是调用的 lettuce 客户端的中的办法

StringRedisTemplate：把 k，v 都是作为 String 解决，应用的是 String 的序列化，可读性好

RedisTemplate：把 k，v 通过了序列化存到 redis。k，v 是序列化的内容，不能间接辨认.

默认应用的 jdk 序列化，能够批改为前提的序列化

序列化：把对象转化为可传输的字节序列过程称为序列化。

反序列化：把字节序列还原为对象的过程称为反序列化。

为什么须要序列化

序列化最终的目标是为了对象能够跨平台存储，和进行网络传输。而咱们进行跨平台存储和网络传输的形式就是 IO，而咱们的 IO 反对的数据格式就是字节数组。咱们必须在把对象转成字节数组的时候就制订一种规定（序列化），那么咱们从 IO 流外面读出数据的时候再以这种规定把对象还原回来（反序列化）。

什么状况下须要序列化

通过下面我想你曾经晓得了但凡须要进行“跨平台存储”和”网络传输”的数据，都须要进行序列化。

实质上存储和网络传输都须要通过把一个对象状态保留成一种跨平台辨认的字节格局，而后其余的平台才能够通过字节信息解析还原对象信息。

序列化的形式

序列化只是一种拆装组装对象的规定，那么这种规定必定也可能有多种多样，比方当初常见的序列化形式有：

JDK（不反对跨语言）、JSON、XML、Hessian、Kryo（不反对跨语言）、Thrift、Protofbuff、

Student(name=zs, age=20) —- {“name”:”zs”, “age”:20}

java 的序列化：把 java 对象转为 byte[], 二进制数据

json 序列化：json 序列化性能将对象转换为 JSON 格局或从 JSON 格局转换对象。例如把一个 Student 对象转换为 JSON 字符串 {“name”:” 李四 ”, “age”:29} )，反序列化 (将 JSON 字符串 {“name”:” 李四 ”, “age”:29} 转换为 Student 对象 )

设置 key 或者 value 的序列化形式

// 应用 RedisTemplate，在存取值之前，设置序列化
// 设置 key 应用 String 的序列化
redisTemplate.setKeySerializer(new StringRedisSerializer());

// 设置 value 的序列化
redisTemplate.setValueSerializer(new StringRedisSerializer());

redisTemplate.opsForValue().set(k,v);

https://github.com/apache/dub…

独立的 maven 我的项目：定义了接口和数据类

public class Student implements Serializable {
    private static final long serialVersionUID = 1901229007746699151L;

    private Integer id;
    private String name;
    private Integer age;
}

public interface StudentService {Student queryStudent(Integer id);
}

创立 SpringBoot 我的项目

1）pom.xml

<dependencies>

   <!-- 退出公共我的项目的 gav-->
   <dependency>
      <groupId>com.bjpowernode</groupId>
      <artifactId>022-interface-api</artifactId>
      <version>1.0.0</version>
   </dependency>

   <!--dubbo 依赖 -->
   <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-spring-boot-starter</artifactId>
      <version>2.7.8</version>
   </dependency>


   <!--zookeeper 依赖 -->
   <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-dependencies-zookeeper</artifactId>
      <version>2.7.8</version>
      <type>pom</type>
      <exclusions>
         <!-- 排除 log4j 依赖 -->
         <exclusion>
            <artifactId>slf4j-log4j12</artifactId>
            <groupId>org.slf4j</groupId>
         </exclusion>
      </exclusions>
   </dependency>
</dependencies>

2）实现接口

/**
 * 应用 dubbo 中的注解裸露服务
 * @Component 能够不必加
 */
@DubboService(interfaceClass = StudentService.class,version = "1.0",timeout = 5000)
public class StudentServiceImpl implements StudentService {
    @Override
    public Student queryStudent(Integer id) {Student student  = new Student();
        if(1001 == id){student.setId(1001);
            student.setName("------1001- 张三");
            student.setAge(20);
        } else if(1002  == id){student.setId(1002);
            student.setName("#######1002- 李四");
            student.setAge(22);
        }

        return student;
    }
}

3）application.properties

# 配置服务名称 dubbo:application name="名称"
spring.application.name=studentservice-provider

#配置扫描的包，扫描的 @DubboService
dubbo.scan.base-packages=com.bjpowernode.service

#配置 dubbo 协定
#dubbo.protocol.name=dubbo
#dubbo.protocol.port=20881

#注册核心
dubbo.registry.address=zookeeper://localhost:2181

4) 在启动类的下面

@SpringBootApplication
@EnableDubbo
public class ProviderApplication {public static void main(String[] args) {SpringApplication.run(ProviderApplication.class, args);
   }
}

创立 SpringBoot 我的项目

1）pom.xml

<dependencies>

   <!-- 退出公共我的项目的 gav-->
   <dependency>
      <groupId>com.bjpowernode</groupId>
      <artifactId>022-interface-api</artifactId>
      <version>1.0.0</version>
   </dependency>

   <!--dubbo 依赖 -->
   <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-spring-boot-starter</artifactId>
      <version>2.7.8</version>
   </dependency>


   <!--zookeeper 依赖 -->
   <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-dependencies-zookeeper</artifactId>
      <version>2.7.8</version>
      <type>pom</type>
      <exclusions>
         <!-- 排除 log4j 依赖 -->
         <exclusion>
            <artifactId>slf4j-log4j12</artifactId>
            <groupId>org.slf4j</groupId>
         </exclusion>
      </exclusions>
   </dependency>
</dependencies>

2) 创立了 Controller 或者 Service 都能够

@RestController
public class DubboController {

    /**
     * 援用近程服务，把创立好的代理对象，注入给 studentService
     */
    //@DubboReference(interfaceClass = StudentService.class,version = "1.0")

    /**
     * 没有应用 interfaceClass，默认的就是 援用类型的 数据类型
      */
    @DubboReference(version = "1.0")
    private StudentService studentService;

    @GetMapping("/query")
    public String queryStudent(Integer id){Student student   = studentService.queryStudent(id);
        return "调用近程接口，获取对象："+student;
    }
}

3）application.properties

# 指定服务名称
spring.application.name=consumer-application
#指定注册核心
dubbo.registry.address=zookeeper://localhost:2181

应用的技术：SpringBoot ,Dubbo, Redis, MyBatis

Student 表：

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传 (img-wjofTbqS-1645599534521)(D:\course\25-SpringBoot\ 笔记 \images\image-20210119150418295.png)]

CREATE TABLE student (
id int(11) NOT NULL AUTO_INCREMENT,
name varchar(255) COLLATE utf8_bin DEFAULT NULL,
phone varchar(11) COLLATE utf8_bin DEFAULT NULL,
age int(11) DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

1) 注册学生

phone 必须惟一，如果曾经存在了手机号，注册失败的。

int addStudent(Student student);

返回值：int

1：注册胜利

2：手机号曾经存在

name 至多两个字符，

age 必须大于 0

2）查问学生，依据 id 查问，此学生。

先到 redis 查问学生，如果 redis 没有此学生，从数据库查问，把查问到的学生放入到 redis。

前面再次查问这个学生应该从 redis 就能获取到。

Student queryStudent(Integer id);

3) 应用 Dubbo 框架，addStudent, queryStudent 是有服务提供者实现的。

消费者能够是一个 Controller，调用提供者的两个办法。实现注册和查问。

4）页面应用 html 和 ajax，jquery。

在 html 页面中提供 form 注册学生，提供文本框输出 id，进行查问。

注册和查问都应用 ajax 技术。

html，jquery.js 都放到 resources/static 目录中

1. 创立了一个 jsp 利用

2. 批改 pom.xml

1) 指定打包后的文件名称

<build>
   <!-- 打包后的文件名称 -->
   <finalName>myboot</finalName>
</build>

2) 指定 jsp 编译目录

<!--resources 插件，把 jsp 编译到指定的目录 -->
<resources>
   <resource>
      <directory>src/main/webapp</directory>
      <targetPath>META-INF/resources</targetPath>
      <includes>
         <include>**/*.*</include>
      </includes>
   </resource>

   <!-- 应用了 mybatis，而且 mapper 文件放在 src/main/java 目录 -->
   <resource>
      <directory>src/main/java</directory>
      <includes>
         <include>**/*.xml</include>
      </includes>
   </resource>

   <!-- 把 src/main/resources 上面的所有文件，都蕴含到 classes 目录 -->
   <resource>
      <directory>src/main/resources</directory>
      <includes>
         <include>**/*.*</include>
      </includes>
   </resource>
</resources>

3）执行打包是 war

<!-- 打包类型 -->
<packaging>war</packaging>

4）主启动类继承 SpringBootServletInitializer

/**
 * SpringBootServletInitializer: 继承这个类，能力应用独立 tomcat 服务器
 */
@SpringBootApplication
public class JspApplication  extends SpringBootServletInitializer  {public static void main(String[] args) {SpringApplication.run(JspApplication.class, args);
   }

   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {return builder.sources(JspApplication.class);
   }
}

5）部署 war

把 war 放到 tomcat 等服务器的公布目录中。tomcat 为例，myboot.war 放到 tomcat/webapps 目录。

1. 创立了一个蕴含了 jsp 的我的项目

2. 批改 pom.xml

1) 指定打包后的文件名称

<build>
   <!-- 打包后的文件名称 -->
   <finalName>myboot</finalName>
</build>

2) 指定 springboot-maven-plugin 版本

<plugins>
   <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
      <!-- 打包 jar，有 jsp 文件时，必须指定 maven-plugin 插件的版本是 1.4.2.RELEASE-->
      <version>1.4.2.RELEASE</version>
   </plugin>
</plugins>

3）最初执行 maven clean package

在 target 目录中，生成 jar 文件，例子是 myboot.jar

执行独立的 springboot 我的项目在 cmd 中 java -jar myboot.jar

Thymeleaf：是应用 java 开发的模板技术，在服务器端运行。把解决后的数据发送给浏览器。

模板是作视图层工作的。显示数据的。Thymeleaf 是基于 Html 语言。Thymleaf 语法是利用在

html 标签中。SpringBoot 框架集成 Thymealeaf, 应用 Thymeleaf 代替 jsp。

Thymeleaf 的官方网站：http://www.thymeleaf.org
Thymeleaf 官网手册：https://www.thymeleaf.org/doc…

规范变量表达式

语法：${key}

作用：获取 key 对于的文本数据，key 是 request 作用域中的 key，应用 request.setAttribute(), model.addAttribute()

在页面中的 html 标签中，应用 th:text=”${key}”

<div style="margin-left: 400px">
    <h3> 规范变量表达式:  ${key}</h3>
    <p th:text="${site}">key 不存在 </p>
    <br/>
    <p> 获取 SysUser 对象 属性值 </p>
    <p th:text="${myuser.id}">id</p>
    <p th:text="${myuser.name}"> 姓名 </p>
    <p th:text="${myuser.sex}"> 姓名：m 男 </p>
    <p th:text="${myuser.age}"> 年龄 </p>
    <p th:text="${myuser.getName()}"> 获取姓名应用 getXXX</p>
</div>

抉择变量表达式（星号变量表达式）

语法：*{key}

作用：获取这个 key 对应的数据，*{key} 须要和 th:object 这个属性一起应用。

目标是简略获取对象的属性值。

<p> 应用 *{} 获取 SysUser 的属性值 </p>
<div th:object="${myuser}">
    <p th:text="*{id}"></p>
    <p th:text="*{name}"></p>
    <p th:text="*{sex}"></p>
    <p th:text="*{age}"></p>

</div>
<p> 应用 *{} 实现的示意 对象的属性值 </p>
<p th:text="*{myuser.name}" ></p>

链接表达式

语法：@{url}

作用：示意链接，能够

 <script src="..."> , <link href="..."> <a href=".."> ,<form action="..."> <img src="...">

属性是放在 html 元素中的，就是 html 元素的属性，退出了 th 前缀。属性的作用不变。退出上 th，属性的值由模板引擎解决了。在属性能够应用变量表达式

例如：

<form action="/loginServlet" method="post"></form>

<form th:action="/loginServlet" th:method="${methodAttr}"></form>

each 循环，能够循环 List，Array

语法：

在一个 html 标签中，应用 th:each

<div th:each="汇合循环成员, 循环的状态变量:${key}">
    <p th:text="${汇合循环成员}" ></p>
</div>

汇合循环成员, 循环的状态变量: 两个名称都是自定义的。“循环的状态变量”这个名称能够不定义，默认是 "汇合循环成员 Stat"

each 循环 Map

在一个 html 标签中，应用 th:each

<div th:each="汇合循环成员, 循环的状态变量:${key}">
    <p th:text="${汇合循环成员.key}" ></p>
    <p th:text="${汇合循环成员.value}" ></p>
</div>

汇合循环成员, 循环的状态变量: 两个名称都是自定义的。“循环的状态变量”这个名称能够不定义，默认是 "汇合循环成员 Stat"

key:map 汇合中的 key
value：map 汇合 key 对应的 value 值

“th:if” : 判断语句，当条件为 true，显示 html 标签体内，反之不显示没有 else 语句

 语法：<div th:if="10 > 0"> 显示文本内容 </div>

还有一个 th:unless 和 th:if 相同的行为

 语法：<div th:unless="10 < 0"> 当条件为 false 显示标签体内容 </div>

例子：if

<div style="margin-left: 400px">
        <h3> if 应用 </h3>
        <p th:if="${sex=='m'}"> 性别是男 </p>
        <p th:if="${isLogin}"> 曾经登录零碎 </p>
        <p th:if="${age > 20}"> 年龄大于 20</p>
        <!--"" 空字符是 true-->
        <p th:if="${name}">name 是“”</p>
        <!--null 是 false-->
        <p th:if="${isOld}"> isOld 是 null</p>
 </div>

例子：unless

 <div style="margin-left: 400px">
        <h3>unless: 判断条件为 false，显示标签体内容 </h3>
        <p th:unless="${sex=='f'}"> 性别是男的 </p>
        <p th:unless="${isLogin}"> 登录零碎 </p>
        <p th:unless="${isOld}"> isOld 是 null </p>
 </div>

th:switch 和 java 中的 swith 一样的

 语法：<div th:switch="要比对的值">
    <p th:case="值 1">
        后果 1
    </p>
    <p th:case="值 2">
        后果 2
    </p>
    <p th:case="*">
        默认后果
    </p>
    以上的 case 只有一个语句执行
    
</div>

内联 text：在 html 标签外，获取表达式的值

语法：

<p> 显示姓名是：[[${key}]]</p>

 <div style="margin-left: 400px">
        <h3> 内联 text, 应用内联表达式显示变量的值 </h3>
        <div th:inline="text">
            <p> 我是 [[${name}]]，年龄是 [[${age}]]</p>
            我是 <span th:text="${name}"></span>, 年龄是 <span th:text="${age}"></span>
        </div>

        <div>
            <p> 应用内联 text</p>
            <p> 我是 [[${name}]], 性别是 [[${sex}]]</p>
        </div>
</div>

内联 javascript

 例子：<script type="text/javascript" th:inline="javascript">
         var myname = [[${name}]];
         var myage = [[${age}]];

         //alert("获取的模板中数据"+ myname + ","+myage)

        function fun(){alert("单击事件，获取数据"+ myname + ","+ [[${sex}]])
        }
    </script>

例子：

 <div style="margin-left: 400px">
       <h3> 文本字面量: 应用单引号括起来的字符串 </h3>
       <p th:text="'我是'+${name}+', 我所在的城市'+${city}"> 数据显示 </p>

       <h3> 数字字面量 </h3>
        <p th:if="${20>5}"> 20 大于 5</p>

        <h3>boolean 字面量 </h3>
        <p th:if="${isLogin == true}"> 用户曾经登录零碎 </p>

        <h3>null 字面量 </h3>
        <p th:if="${myuser != null}"> 有 myuser 数据 </p>
    </div>

连贯字符串有两种语法

1）语法应用单引号括起来字符串，应用 + 连贯其余的字符串或者表达式

  <p th:text="'我是'+${name}+', 我所在的城市'+${city}"> 数据显示 </p>

2）语法：应用双竖线，| 字符串和表达式 |

<p th:text="| 我是 ${name}, 我所在城市 ${city|">
    显示数据
</p>

例子：

    <div style="margin-left: 400px">
       <h3> 字符串连贯形式 1：应用单引号括起来的字符串 </h3>
       <p th:text="'我是'+${name}+', 我所在的城市'+${city}"> 数据显示 </p>
        <br/>
        <br/>
        <h3> 字符串连贯形式 2：| 字符串和表达式 |</h3>
        <p th:text="| 我是 ${name}, 所在城市 ${city}, 其他人 ${myuser.name}|"></p>
    </div>

 算术运 算：+ , - - , * , / , %
关系比拟 : > , < , >= , <= (gt , lt , ge , le)
相等判断：== , != (eq , ne)


<div style="margin-left: 400px">
        <h3> 应用运算符 </h3>
        <p th:text="${age > 10}"> 年龄大于 10 </p>
        <p th:text="${20 + 30}"> 显示运算后果 </p>
        <p th:if="${myuser == null}">myuser 是 null</p>
        <p th:if="${myuser eq null}">myuser 是 null</p>
        <p th:if="${myuser ne null}">myuser 不是 null</p>

        <p th:text="${isLogin == true ?' 用户曾经登录 ':' 用户须要登录 '}"></p>
        <p th:text="${isLogin == true ? ( age > 10 ?' 用户是大于 10 的 ':' 用户年龄比拟小 ') :' 用户须要登录 '}"></p>

    </div>

三元运算符：表达式？true 的后果 : false 的后果

三元运算符能够嵌套

文档地址：https://www.thymeleaf.org/doc…

session 示意 Map 对象的，是 #session 的简略示意形式，用来获取 session 中指定的 key 的值

#session.getAttribute(“loginname”) == session.loginname

这些是内置对象，能够在模板文件中间接应用。

 例子：<div style="margin-left: 350px">
        <h3> 内置对象 #request,#session，session 的应用 </h3>
        <p> 获取作用域中的数据 </p>
        <p th:text="${#request.getAttribute('requestData')}"></p>
        <p th:text="${#session.getAttribute('sessionData')}"></p>
        <p th:text="${session.loginname}"></p>

        <br/>
        <br/>
        <h3> 应用内置对象的办法 </h3>
        getRequestURL=<span th:text="${#request.getRequestURL()}"></span><br/>
        getRequestURI=<span th:text="${#request.getRequestURI()}"></span><br/>
        getQueryString=<span th:text="${#request.getQueryString()}"></span><br/>
        getContextPath=<span th:text="${#request.getContextPath()}"></span><br/>
        getServerName=<span th:text="${#request.getServerName()}"></span><br/>
        getServerPort=<span th:text="${#request.getServerPort()}"></span><br/>
</div>

内置工具类型：Thymeleaf 本人的一些类，提供对 string，date，汇合的一些解决办法

<div style="margin-left: 350px">
      <h3> 日期类对象 #dates</h3>
      <p th:text="${#dates.format(mydate)}"></p>
      <p th:text="${#dates.format(mydate,'yyyy-MM-dd')}"></p>
      <p th:text="${#dates.format(mydate,'yyyy-MM-dd HH:mm:ss')}"></p>
      <p th:text="${#dates.year(mydate)}"></p>
      <p th:text="${#dates.month(mydate)}"></p>
      <p th:text="${#dates.monthName(mydate)}"></p>
      <p th:text="${#dates.createNow()}"></p>
      <br/>

      <h3> 内置工具类 #numbers，操作数字的 </h3>
      <p th:text="${#numbers.formatCurrency(mynum)}"></p>
      <p th:text="${#numbers.formatDecimal(mynum,5,2)}"></p>

      <br/>
      <h3> 内置工具类 #strings, 操作字符串 </h3>
      <p th:text="${#strings.toUpperCase(mystr)}"></p>
      <p th:text="${#strings.indexOf(mystr,'power')}"></p>
      <p th:text="${#strings.substring(mystr,2,5)}"></p>
      <p th:text="${#strings.substring(mystr,2)}"></p>
      <p th:text="${#strings.concat(mystr,'---java 开发的黄埔军校 ---')}"></p>
      <p th:text="${#strings.length(mystr)}"></p>
      <p th:text="${#strings.length('hello')}"></p>
      <p th:unless="${#strings.isEmpty(mystr)}"> mystring 不是 空字符串  </p>

      <br/>
      <h3> 内置工具类 #lists, 操作 list 汇合 </h3>
      <p th:text="${#lists.size(mylist)}"></p>
      <p th:if="${#lists.contains(mylist,'a')}"> 有成员 a </p>
      <p th:if="!${#lists.isEmpty(mylist)}"> list 汇合有多个成员 </p>

      <br/>
      <h3> 解决 null</h3>
      <p th:text="${zoo?.dog?.name}"></p>

  </div>

模板是内容复用，定义一次，在其余的模板文件中屡次应用。

模板应用：

1. 定义模板

2. 应用模板

模板定义语法：

th:fragment="模板自定义名称"

例如：<div th:fragment="head">
    <p>
        能源节点 -java 开发
    </p>
    <p>
        www.bjpowernode.com
    </p>
</div>

援用模板语法：

1) ~{templatename :: selector}
   templatename:  文件名称
   selector：自定义模板名称
2）templatename :: selector
   templatename:  文件名称
   selector：自定义模板名称

对于应用模板：有蕴含模板（th:include），插入模板 (th:insert)

Spring + SpringMVC + SpringBoot

 创建对象的：@Controller: 放在类的下面，创立控制器对象，注入到容器中
@RestController: 放在类的下面，创立控制器对象，注入到容器中。作用：复合注解是 @Controller , @ResponseBody, 应用这个注解类的，外面的控制器办法的返回值                   都是数据

@Service：放在业务层的实现类下面，创立 service 对象，注入到容器
@Repository : 放在 dao 层的实现类下面，创立 dao 对象，放入到容器。没有应用这个注解，是因为当初应用 MyBatis 框               架，dao 对象是 MyBatis 通过代理生成的。不须要应用 @Repository、所以没有应用。@Component:  放在类的下面，创立此类的对象，放入到容器中。赋值的：@Value：简略类型的赋值，例如 在属性的下面应用 @Value("李四") private String name
          还能够应用 @Value, 获取配置文件者的数据（properties 或 yml）。@Value("${server.port}") private Integer port

@Autowired: 援用类型赋值主动注入的，反对 byName, byType. 默认是 byType。放在属性的下面，也能够放在结构             办法的下面。举荐是放在构造方法的下面
@Qualifer:  给援用类型赋值，应用 byName 形式。@Autowird, @Qualifer 都是 Spring 框架提供的。@Resource：来自 jdk 中的定义，javax.annotation。实现援用类型的主动注入，反对 byName, byType.
             默认是 byName, 如果 byName 失败，再应用 byType 注入。在属性下面应用


其余：@Configuration：放在类的下面，示意这是个配置类，相当于 xml 配置文件

@Bean：放在办法的下面，把办法的返回值对象，注入到 spring 容器中。@ImportResource：加载其余的 xml 配置文件，把文件中的对象注入到 spring 容器中

@PropertySource：读取其余的 properties 属性配置文件

@ComponentScan：扫描器，指定包名，扫描注解的

@ResponseBody: 放在办法的下面，示意办法的返回值是数据，不是视图
@RequestBody : 把申请体中的数据，读取进去，转为 java 对象应用。@ControllerAdvice:  控制器加强，放在类的下面，示意此类提供了办法，能够对 controller 加强性能。@ExceptionHandler : 解决异样的，放在办法的下面

@Transcational :  处理事务的，放在 service 实现类的 public 办法下面，示意此办法有事务


SpringBoot 中应用的注解
    
@SpringBootApplication：放在启动类下面，蕴含了 @SpringBootConfiguration
                          @EnableAutoConfiguration，@ComponentScan


    
MyBatis 相干的注解

@Mapper：放在类的下面，让 MyBatis 找到接口，创立他的代理对象    
@MapperScan : 放在主类的下面，指定扫描的包，把这个包中的所有接口都创立代理对象。对象注入到容器中
@Param：放在 dao 接口的办法的形参后面，作为命名参数应用的。Dubbo 注解
@DubboService: 在提供者端应用的，裸露服务的，放在接口的实现类下面
@DubboReference:  在消费者端应用的，援用近程服务，放在属性下面应用。@EnableDubbo : 放在主类下面，示意以后援用启用 Dubbo 性能。

援用模板语法：

1) ~{templatename :: selector}
   templatename:  文件名称
   selector：自定义模板名称
2）templatename :: selector
   templatename:  文件名称
   selector：自定义模板名称

对于应用模板：有蕴含模板（th:include），插入模板 (th:insert)

Spring + SpringMVC + SpringBoot

 创建对象的：@Controller: 放在类的下面，创立控制器对象，注入到容器中
@RestController: 放在类的下面，创立控制器对象，注入到容器中。作用：复合注解是 @Controller , @ResponseBody, 应用这个注解类的，外面的控制器办法的返回值                   都是数据

@Service：放在业务层的实现类下面，创立 service 对象，注入到容器
@Repository : 放在 dao 层的实现类下面，创立 dao 对象，放入到容器。没有应用这个注解，是因为当初应用 MyBatis 框               架，dao 对象是 MyBatis 通过代理生成的。不须要应用 @Repository、所以没有应用。@Component:  放在类的下面，创立此类的对象，放入到容器中。赋值的：@Value：简略类型的赋值，例如 在属性的下面应用 @Value("李四") private String name
          还能够应用 @Value, 获取配置文件者的数据（properties 或 yml）。@Value("${server.port}") private Integer port

@Autowired: 援用类型赋值主动注入的，反对 byName, byType. 默认是 byType。放在属性的下面，也能够放在结构             办法的下面。举荐是放在构造方法的下面
@Qualifer:  给援用类型赋值，应用 byName 形式。@Autowird, @Qualifer 都是 Spring 框架提供的。@Resource：来自 jdk 中的定义，javax.annotation。实现援用类型的主动注入，反对 byName, byType.
             默认是 byName, 如果 byName 失败，再应用 byType 注入。在属性下面应用


其余：@Configuration：放在类的下面，示意这是个配置类，相当于 xml 配置文件

@Bean：放在办法的下面，把办法的返回值对象，注入到 spring 容器中。@ImportResource：加载其余的 xml 配置文件，把文件中的对象注入到 spring 容器中

@PropertySource：读取其余的 properties 属性配置文件

@ComponentScan：扫描器，指定包名，扫描注解的

@ResponseBody: 放在办法的下面，示意办法的返回值是数据，不是视图
@RequestBody : 把申请体中的数据，读取进去，转为 java 对象应用。@ControllerAdvice:  控制器加强，放在类的下面，示意此类提供了办法，能够对 controller 加强性能。@ExceptionHandler : 解决异样的，放在办法的下面

@Transcational :  处理事务的，放在 service 实现类的 public 办法下面，示意此办法有事务


SpringBoot 中应用的注解
    
@SpringBootApplication：放在启动类下面，蕴含了 @SpringBootConfiguration
                          @EnableAutoConfiguration，@ComponentScan


    
MyBatis 相干的注解

@Mapper：放在类的下面，让 MyBatis 找到接口，创立他的代理对象    
@MapperScan : 放在主类的下面，指定扫描的包，把这个包中的所有接口都创立代理对象。对象注入到容器中
@Param：放在 dao 接口的办法的形参后面，作为命名参数应用的。Dubbo 注解
@DubboService: 在提供者端应用的，裸露服务的，放在接口的实现类下面
@DubboReference:  在消费者端应用的，援用近程服务，放在属性下面应用。@EnableDubbo : 放在主类下面，示意以后援用启用 Dubbo 性能。

关于java:万字长文史上最全的SpringBoot学习笔记

SpringBoot

第一章 JavaConfig

1.1 JavaConfig

1.2 @ImporResource

1.3 @PropertyResource

第二 章 Spring Boot

2.1 介绍

2.2 创立 Spring Boot 我的项目

2.2.1 第一种形式，应用 Spring 提供的初始化器，就是向导创立 SpringBoot 利用

2.2.1 应用国内的地址

2.3 注解的应用

2.4 SpringBoot 的配置文件

2.5 多环境配置

2.6 @ConfigurationProperties

2.7 应用 jsp

2.8 应用容器

2.9 ComnandLineRunner 接口，ApplcationRunner 接口

第三章 Web 组件

3.1 拦截器

3.2 Servlet

3.3 过滤器 Filter

3.4 字符集过滤器

第四章 ORM 操作 MySQL

第一种形式：@Mapper

第二种形式 @MapperScan

第三种形式：Mapper 文件和 Dao 接口离开治理

第四个 事务

第五章 接口架构格调 —RESTful

5.1 REST

5.2 在页面中或者 ajax 中，反对 put，delete 申请

第六章 Redis

6.1 配置 Windows 版本的 redis

6.2 比照 StringRedisTemplate 和 RedisTemplate

第七章 SpringBoot 集成 Dubbo

7.1 看 SpringBoot 继承 Dubbo 的文档

7.2 公共我的项目

7.3 提供者

7.4 消费者

7.5 练习

第八章 打包

8.1 打包 war

8.2 打包为 jar

第九章 Thymeleaf 模板引擎

9.1 表达式

9.2 Thymeleaf 属性

9.3 each

9.4 th:if

9.5 th:switch

9.6 th:inline

9.7 字面量

9.8 字符串连贯

9.9 运算符

9.10 内置对象

request 示意 HttpServletRequest

session 示意 HttpSession 对象

9.11 内置工具类

dates: 解决日器的工具类

numbers: 解决数字的

lists: 解决 list 汇合的

9.12 自定义模板

第十章 总结

10.1 注解

第十章 总结

10.1 注解

Just My Socks（注册教程 内含优惠码）

第二章 Spring Boot

第四个事务

第五章接口架构格调 —RESTful

第八章打包

第十章总结

第十章总结

Just My Socks（注册教程内含优惠码）