SpringBoot2

为什么会有springboot----->因为在spring、springmvc中需要写大量的配置文件，还需要配置各种对象，把使用的对象放入到spring容器中才能使用对象，还需要了解其他框架配置规则。

Spring家族推出springboot框架就是为了简化spring的配置与开发，使得在基于Spring框架的开发中开发起来更快速更方便，简化或减少相关的配置，提高开发效率； 

SpringBoot 就相当于 不需要配置文件的Spring+SpringMVC------>常用的框架和第三方库都已经配置好了。 //开发效率高

JavaConfig：

                        spring框架提供的一个功能，使用java类作为xml配置文件的替代，是配置spring容器的纯java的方式。
                        在这个java类(配置文件类)这可以创建java对象，把对象放入spring容器中（注入到容器）
                        Spring使用Xml作为容器配置文件------------》在3.0以后加入了JavaConfig（java类配置容器）配置Spring IOC容器的纯Java方法。

使用：创建普通类，定义方法，方法返回值是对象 
 

@Configuration注解：                        位置：类上                        作用：表示这个类是作为配置文件使用的。                                  //相当于spring配置文件xml
                属性：

@Bean注解：                                       位置：方法上                    作用：声明对象，把方法的返回值(对象)注入到容器中。              //相当于标签
                属性：name                指定对象的名称（说明：若不指定对象的名称，默认方法名是id）                                                   //相当于标签的id属性

---

注解的位置对应之前spring中配置文件中的标签

@ImportResource注解：           位置：类上           作用：导入已有的xml配置文件                                                       //相当于xml文件的
                属性：value                               String数组，指定配置文件的位置（一般为calsspath:xxx类路径下） 

@ComponentScan注解              位置：类上          作用：告诉配置文件类，去哪里找其他注解 //相当于组件扫描器标签
                属性：basePackages                读取注其他注解所在的包名                               
 

@PropertyResource注解：        位置：类上           作用：把让spring框架的配置文件类读到属性配置文件（properties）     
                属性：value                                String数组，指定.properties属性文件的位置（一般为calsspath:xxx类路径下） 
                                                                                                                                                            //相当于 

     使用：                                                                                                                

1.  在resources目录下创建xxx.properties文件，使用k=v格式提供数据  
2. 根据xxx.properties文件创建一个Java普通类用来获取数据，私有属性为k
3. 在类上使用@Component("id")使用注解生成对象放入容器      
4. 在属性上使用@Value（value="${key}"）  
5. 在JavaConfig的Java类上@PropertyResource(value="classpath:xxx属性文件")   把让spring框架的配置文件类读到属性文件           
6. 在JavaConfig的Java类上@ComponentScan(basePackages = "类所在包名")       //组件扫描器找到注解生成对象     

 

使用JavaConfig：在JavaConfig创建容器对象：ApplicationContext ctx = new AnnotationConfigApplicationContext(配置文件类.class);
                               获取对象：Student student = (Student) ctx.getBean("id名");       //注意要转换类型，因为都是Object

---

 SpringBoot

SpringBoot是Spring中的一个成员，可以简化spring、springmvc的使用。核心还是IoC容器

特点：创建spring应用
           内嵌的tomcat， jetty ， Undertow 服务器
           提供了starter起步依赖，简化应用的配置。   //比如使用MyBatis框架 ， 需要在Spring项目中，配置MyBatis的对象 SqlSessionFactory ， Dao的代理对象
                                                                                  //现在在SpringBoot项目中，在pom.xml里面, 加入一个 mybatis-spring-boot-starter依赖，上面的就配置好了
           自动配置：尽可能去配置spring和第三方库。（就是把spring中的、第三方库中的对象都创建好，放到容器中， 开发人员可以直接使用）
           提供了健康检查， 统计，外部化配置（属性配置文件就是外部化配置）
           不用生成代码， 不用使用xml，做配置

创建springboot项目 

第一种方式：使用Spring提供的初始化器， 就是向导创建SpringBoot应用         //使用地址：https://start.spring.io/            //需要联网
        
               

        .mvn                与maven有关的                //可以删除
        mvnw               与maven有关的   //可以删除
        mvnw.cmd       与maven有关的    //可以删除
        HELP.md        描述文件                //可以删除
        .gitignore        git忽略文件                //不用管
        xxx.iml            IDEA自己的文件        //不用管
重点：
        pom.xml
        src        

           pom.xml文件：        

    4.0.0
    springboot项目的父项目
    
        org.springframework.boot
        spring-boot-starter-parent
        2.6.4
         
    
    当前项目的坐标
    groupId
    artifactId
    0.0.1-SNAPSHOT
    artifactId                    可以删除不要
    artifactId      可以删除不要
    jdk版本
    
        1.8
    
    依赖
    
        web依赖
        
            org.springframework.boot
            spring-boot-starter-web    web项目的起步依赖，会加入相关需要的的jar包
        
        测试依赖
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
    
    maven插件
    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

                调试项目：             

第二种方式：使用Spring提供的初始化器， 就是向导创建SpringBoot应用         //使用地址：https://start.springboot.io/（上面的地址是国外的，经常访问失败，所以用国内的）
第三种方式：使用浏览器进入上面的网址，在生成项目，下载压缩包，解压后导入idea---maven工程就可以
第四种方式：maven----不用选模板----创建普通的maven项目-----在pom.xml加入父项目和起步依赖
                        在resources文件夹种新建：2个文件夹：static、templates     1个文件application.properties

@SpringBootApplication 
public class Application {         //主启动类
    public static void main(String[] args) {          //主方法       
        SpringApplication.run(Application.class,args);     //启动spring IoC容器，返回容器
    } 
}

---

@SpringBootApplication注解：                                        位置：主类上

        复合注解：由@SpringBootConfiguration        （配置文件）        三个注解组成
                              @EnableAutoConfiguration       （自动配置功能）
                              @ComponentScan                    （扫描注解）

        
       

        @SpringBootConfiguration注解：           //该注解的注解：@Configuration注解                     //该类可以当作配置文件来用，可以使用Bean（标签、注解）声明对象，注入到容器

@Configuration
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

         @EnableAutoConfiguration：        启用自动配置， 把java对象配置好，注入到spring容器中         //例如可以把mybatis的对象创建好，放入到容器中

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

         

 Spring Boot配置文件：.properties格式文件（k=v）、.yml格式文件（k: v）

核心配置文件：名字必须以 application 开始        //如：application.properties、application.yml      若2个都配置则冲突，优先用.properties

        application.properties格式文件：

#设置端口号
server.port=8080

#应用的上下文路径contextpath   项目
server.servlet.context-path=/xxx

        application.yml格式文件：     //有层级关系：一般习惯2个空格                  k:与v有一个空格                           //推荐使用

server: 
  port: 8080
    servlet: 
      context-path: /xxx

        多环境配置：开发时，项目会经历多个阶段（开发->测试->上线），每个阶段环境配置不同（如：端口、上下文根、数据库等）
                              为了方便不同环境来回切换，SpringBoot 提供了多环境配置：为每个环境创建一个配置文件，命名规则： application-自定义环境标识.properties|yml
                              在application.properties|yml设置激活哪个配置文件      //以application.properties为例

#指定使用的环境文件 
spring.profiles.active=自定义环境标识


#自定义环境标识习惯一般用：dev开发、test测试、online上线

---

Spring Boot 自定义配置：

@value("${key}")注解        位置：类的属性上                        从属性配置文件（application.properties、application.yml）获取数据，赋值给属性

@ConfigurationProperties注解                                        将整个文件映射成一个对象
        属性：prefix                值为字符串，为配置文件中key的.之前的字符串           //如：     aaa.bbb=xxxx           aaa为.之前的值     bbb为.之后的值    这样做是为了抽取想要的属性
        使用 1）创建一个类，定义私有属性(名与配置文件的key名相同，注意:key名是.之后的字符串)
                2）在类上使用@ConfigurationProperties注解进行映射
                3）在类上使用@Component注解创建对象      
                类中使用了 ConfigurationProperties 注解， IDEA 会出现一个警告 ，不影响程序的执行。解决：可以加入依赖项
                                                        
                                                        
                                                                org.springframework.boot
                                                                spring-boot-configuration-processor
                                                                true
                                                        

Spring Boot中使用JSP 

                                                //   不推荐使用jsp在spring boot，会用模板技术来替代jsp作为视图使用

1. 加入一个处理jsp的依赖，负责编译jsp文件

    
    
    
       org.apache.tomcat.embed 
       tomcat-embed-jasper 
    

2. 如果需要使用servlet， jsp，jstl的功能，加入其依赖

   
   	javax.servlet
   	jstl
   
   
   
   	javax.servlet
   	javax.servlet-api
   
   
   
   javax.servlet.jsp
   	javax.servlet.jsp-api
   	2.3.1
   

3. 创建存放jsp的目录：webapp        新建有index.jsp
   

4. 在pom.xml指定jsp文件的编译后的存放目录         META-INF/resources

    
        
            
           src/main/webapp 
           
           META-INF/resources
           
            
               **/*.* 
           
       
   

5. 创建Controller，访问jsp                    //直接使用视图逻辑名称

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

   #配置SpringMVC的视图解析器 
   #其中：/相当于src/main/webapp目录 
   spring.mvc.view.prefix=/ 
   spring.mvc.view.suffix=.jsp

 Spring Boot中使用 ApplicationContext

在main方法中SpringApplication.run()方法获取返回的Spring容器对象
run方法：

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

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

在容器启动后执行后执行一些内容。比如读取配置文件，数据库连接之类的。SpringBoot 给我们提供了两个接口来帮助我们实现这种需求：在启动类上实现该接口

CommandLineRunner接口
        方法：run                        //区别：方法的参数为 String数组                        ​​​​  ​​​void  run(String... args)         是main方法传入的参数
ApplicationRunner接口
        方法：run                        //区别：方法的参数为 ApplicationArguments        void run(ApplicationArguments args)

执行时间：容器对象创建好后，自动执行run方法

---

 Spring Boot 和 web 组件

拦截器组件：

        拦截器是SpringMVC中一种对象，能拦截器对Controller的请求。
        拦截器框架中有系统的拦截器， 还可以自定义拦截器。 实现对请求预先处理。

1. 创建类实现SpringMVC框架的HandlerInterceptor接口                 //即springmvc中的做法
2. 在SpringBoot中注册拦截器                                       //之前是在SpringMVC的配置文件中，声明拦截器。

   @Configuration        //代替xml配置文件
   public class MyAppConfig implements WebMvcConfigurer {        //创建类实现WebMvcConfigurer 接口，该接口有很多springmvc有关的功能
   
       //添加拦截器对象， 注入到容器中
       public void addInterceptors(InterceptorRegistry registry) {     //形参相当于是个注册器
   
           //创建拦截器对象
           HandlerInterceptor interceptor = new LoginInterceptor();
   
           //指定拦截的请求uri地址
           String path []= {"/user/**"};
           //指定不拦截的地址
           String excludePath  [] = {"/user/login"};
           registry.addInterceptor(interceptor)            //添加拦截器
                   .addPathPatterns(path)                  //拦截哪个请求地址
                   .excludePathPatterns(excludePath);      //不拦截哪个请求地址
   
       }
   }

Servlet组件：

1. 创建Servlet类。 创建类继承HttpServlet
2. 在SpringBoot注册Servlet ，让框架能找到Servlet                     //在自定义类中实现返回值ServletRegistrationBean 的方法

   @Configuration
   public class WebApplictionConfig {
   
       //定义方法， 注册Servlet对象
       @Bean
       public ServletRegistrationBean servletRegistrationBean(){
   
           方式一有参构造：public ServletRegistrationBean(T servlet, String... urlMappings)       第一个参数是 Servlet对象， 第二个是url地址
           ServletRegistrationBean bean = new ServletRegistrationBean( new HttpServlet继承类(),"/myservlet");
   ---------------------------------------------------------------------------------------------
           方式二无参构造：public ServletRegistrationBean()
           ServletRegistrationBean bean = new ServletRegistrationBean();
           bean.setServlet( new HttpServlet继承类());        //无参构造创建的需要手动设置servlet对象
           bean.addUrlMappings("/login","/test"); // 手动设置
   
   
   
           return bean;
       }
   }

   
    

过滤器Filter组件

Filter是Servlet规范中的过滤器，可以处理请求， 对请求的参数， 属性进行调整。 常常在过滤器中处理字符编码

1. 创建自定义过滤器类
2. 在SpringBoot中注册Filter                       //在自定义类中实现返回值FilterRegistrationBean的方法 

   @Configuration
   public class WebApplicationConfig {
   
       @Bean
       public FilterRegistrationBean filterRegistrationBean(){
           FilterRegistrationBean bean  = new FilterRegistrationBean();        //同上，也分有参构造、无参构造
           bean.setFilter( new 自定义过滤器类());
           bean.addUrlPatterns("/user/*");
           return bean;
       }
   }

   
    

字符集过滤器组件：

CharacterEncodingFilter : 解决post请求中乱码的问题 
在SpringMVC框架， 在web.xml 注册过滤器。 配置他的属性。

使用方式一：

1. 配置字符集过滤器

   @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;
       }
   }

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

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

   
    

使用方式二：使用已有的CharacterEncodingFilter过滤器                ------>修改application.properties文件

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

  

---

 ORM操作MySQL

ORM：指mybatis框架，mybatis是ORM的一种
spring boot集成mybatis

使用步骤：

1. mybatis起步依赖 ： 完成mybatis对象自动配置， 对象放在容器中
   ，就会加入mybatis的起步依赖、MySQL驱动
2. pom.xml 指定把src/main/java目录中的xml文件包含到classpath中

    
        
           src/main/java 
            
               **/*.xml 
            
        
   

3. 创建实体类Student
4. 创建Dao接口 StudentDao , 创建一个查询学生的方法
5. 创建Dao接口对应的Mapper文件， xml文件， 写sql语句
6. 创建Service层对象， 创建StudentService接口和他的实现类。 去dao对象的方法。完成数据库的操作
7. 创建Controller对象，访问Service
8. 写application.properties文件配置数据库的连接信息

   #连接数据库：
       #使用的是mysql驱动新版本的驱动类
   spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
       #连接数据库的url信息 
   spring.datasource.url=jdbc:mysql://localhost:3306/springdb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
       #用户信息
       spring.datasource.username=root 
       spring.datasource.password=123

方式一：@Mapper注解                                                                位置：放在dao接口的上面                                           //缺点：若有很多接口，则需要加的太多

       作用：告诉MyBatis这是dao接口，创建此接口的代理对象。

方式二：@MapperScan注解                                                        位置：主启动类上

               属性：basePackages                字符串数组，指定接口所在的包名
        作用：找到所有dao接口，创建此接口的代理对象。

Mapper文件和Dao接口分开管理

        把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目录中的文件 ， 编译到目标目录中

   
   
      
         src/main/resources
         
            **/*.*
         
      
   

事务

        Spring Boot 使用事务非常简单，底层依然采用的是Spring本身提供的事务管理

Spring框架中的事务：

1. 管理事务的对象： 事务管理器（接口， 接口有很多的实现类）
2. 声明式事务： 在xml配置文件或者使用注解说明事务控制的内容
   控制事务： 隔离级别，传播行为， 超时时间
3. 事务处理方式：
   1. 方式一：Spring框架中的@Transactional
   2. 方式二：aspectj框架可以在xml配置文件中，声明事务控制的内容

SpringBoot中使用事务： 上面的两种方式都可以。

1. 在业务方法(Service方法)的上面加入@Transactional , 加入注解后，方法就有事务功能了。 //默认使用库的隔离级别， REQUIRED 传播行为； 超时时间  -1
2. 明确的在 主启动类的上面 ，加入@EnableTransactionManager，加入注解后，表示启用事务管理器      //可不使用该注解，最后加上

---

接口架构风格 —RESTful

接口：API（应用程序接口），指是一些预先定义的接口（如函数、HTTP接口-->url)。让开发人员使用，无需访问源码或理解内部工作机制的细节便可以完成对应的功能
           可以指访问servlet， controller的url， 调用其他程序的函数

架构风格： api组织方式（样子）
                   就是一个传统的：http://localhost:9002/mytrans/addStudent?name=lisi&age=26
                   在地址上提供了 访问的资源名称addStudent, 在其后使用了get方式传递参数。

              

---

RESTful架构风格 ：

        之前访问HTTP接口：           http://localhost:8080/boot/order?id=1021&status=1
        RESTFul风格则http地址为：http://localhost:8080/boot/order/1021/1                       //在url种使用名词表示资源，以及资源的访问信息(使用/来分隔对资源的信息)，而不是?参数

        REST（表现层状态转移: ）：是一种客户端和服务器交互时的架构理念和设计原则、理念，不是标准。                //优点：简洁、有层次

        表现层：就是视图层， 显示资源的， 通过视图页面，jsp等等显示操作资源的结果。
        状态： 资源变化
        转移： 资源可以变化的。 资源能创建，new状态， 资源创建后可以查询资源， 能看到资源的内容，这个资源内容 ，可以被修改， 修改后资源 和之前的不一样。

        

        REST中的要素： 用REST表示资源和对资源的操作。 在互联网中，表示一个资源或者一个操作。
                                    资源使用url表示的， 在互联网， 使用的图片，视频， 文本，网页等等都是资源。
                                    资源是用名词表示。

        对资源： 查询资源： 看，通过url找到资源。
                       创建资源： 添加资源
                       更新资源：更新资源 ，编辑
                       删除资源： 去除  

        资源使用url表示，通过名词表示资源。使用http中的动作（请求方式）， 表示对资源的操作（CURD）           
                                 GET: 查询资源 -- sql select        http://localhost:8080/myboot/student/1001           //在url种使用名词表示资源，以及资源的访问信息(使用/来分隔对资源的信息)  
                                                                                    http://localhost:8080/myboot/students/1001/1002
                                 POST: 创建资源 -- sql insert     1）   http://localhost:8080/myboot/student          2)  然后在post请求中传递数据

                通常用get/post，后面2种方式浏览器默认不支持的，可以用get/post来模拟更新删除资源：
                                 PUT： 更新资源 -- sql update     //使用post方式模拟put

	姓名：
    年龄：
             //让后端知道模拟的是PUT

                                 DELETE: 删除资源 -- sql delete    //使用get模拟delete

删除1的数据

                                注意：需要的分页， 排序等参数，依然放在 url的后面， 例如 http://localhost:8080/myboot/students?page=1&pageSize=20
                                                                                        （与资源紧密相关的放在url，其他不是很重要的依然用参数）

对REST风格支持的注解：

@PathVariable : 从url中获取数据                                                                                                          位置： 在逐个接收参数中，在形参定义的前面                                                                                    
        属性：value                路径变量名        
        例如：   @GetMapping("/stydent/{变量名}/{变量名}")        ---->         http://localhost:8080/myboot/student/1001/1002          {变量名}：表示定义路径变量
                      控制器方法(@PathVariable(value = "变量名") Integer id, @PathVariable String 变量名)       //value可简写          //路径变量名和形参名相同时，该属性可省略

@GetMapping: 支持的get请求方式， 等同于 @RequestMapping( method=RequestMethod.GET)                                   位置：控制器方法上
        属性：value                路径      //可以使用路径变量{变量名}表示一个位置                //请求方式+地址：格式必须保证唯一，否则出现多个格式相同的，就不知道访问具体哪个了

@PostMapping: 支持post请求方式 ，等同于 @RequestMapping( method=RequestMethod.POST)                                 同上

@PutMapping: 支持put请求方式， 等同于 @RequestMapping( method=RequestMethod.PUT)                                        同上

@DeleteMapping: 支持delete请求方式， 等同于 @RequestMapping( method=RequestMethod.DELETE)                        同上

@RestController: 复合注解， 是@Controller 和@ResponseBody组合。
        在类的上面使用@RestController ， 表示当前类者的所有方法都加入了 @ResponseBody

       

//使用Postman去测试工具测试请求       //还可以使用idea插件：tool下最后一个选项，与Postman功能相同                 

 

在页面中或者ajax中，支持put，delete请求

在SpringMVC中 有一个过滤器， 支持post请求转为put ,delete

过滤器： org.springframework.web.filter.HiddenHttpMethodFilter                //作用： 把请求中的post请求转为 put ， delete

实现步骤：在springmvc框架中，需要在web.xml文件中配置去启用(方式直接上网上找)，在spring boot框架中该过滤器已启用，直接用就可以：

1. application.properties(yml) : 开启使用 HiddenHttpMethodFilter 过滤器

   #启用 HiddenHttpMethodFilter 这个过滤器， 支持post请求转为 put，delete
   spring.mvc.hiddenmethod.filter.enabled=true

2. 在请求页面中，包含 _method参数， 他的值是 put， delete ， 发起这个请求使用的post方式

            
   	姓名：
       年龄：
            
   

---

springboot继承redis 

redis是一个中间件：是一个独立的服务器
java中著名的客户端：Jedis、lettuce、Redisson
Spring,SpringBoot中有 一个RedisTemplate类（StringRedisTemplate类） ，处理和redis的交互

windows环境redis的客户端和服务端：只做开发使用

redisclient-win32.x86_64.2.0.jar : Redis图形界面客户端       //执行方式： 在这个文件所在的目录， 执行 java -jar redisclient-win32.x86_64.2.0.jar

添加依赖：
里面有：

   org.springframework.boot
   spring-boot-starter-data-redis

data-redis使用的   lettuce 客户端库

在程序中使用RedisTemplate类的方法 操作redis数据， 实际就是调用的lettuce 客户端的中的方法

 在配置文件application.properties指定redis配置信息：

#指定redis 
spring.redis.host=localhost     //IP
spring.redis.port=6379         //端口号

#spring.redis.password=123456        //有密码就设置上

创建controller层：
 

@RestController 
public class RedisController { 

    /*注入RedisTemplate 
      泛型key，value都是String ，或者Object， 不写 
          RedisTemplate
          RedisTemplate
          RedisTemplate 

      注意：RedisTemplate对象的名称要写成redisTemplate    */

    @Resource 
    private RedisTemplate redisTemplate;             //有对象是因为加了起步依赖，有框架创建对象，然后注入到这里         默认使用JDK序列化

    @StringResource 
    private StringRedisTemplate stringredisTemplate;  //道理如上     默认使用String序列化
    



    @GetMapping("/myname") 
    public String getName(){
        //操作redis什么类型数据就要先获取操作对象
        //获取RedisTemplate或StringRedisTemplate操作对象
        redisTemplate.opsFor数据类型();
        //通过操作对象的方法来操作数据
        操作对象.set("xx","xxx")
               .xxx(参数)       //方法名与redis命令名相同    
        --------------------------------------------------------------    
         
        //设置RedisTemplate或StringRedisTemplate操作对象的序列化
          操作对象获取值的适合就会自动反序列化回来，所需取出值直接用就可
        //可以设置key的序列化，也可以设置value的序列化，还可以同时设置
        

        设置RedisTemplate对象的key序列化      //例子设为String方式
        redisTemplate.setKeySerializer( new StringRedisSerializer());   //查看方法的参数类型，查看参数的实现类---就是序列化方式，new对象作为参数
        设置RedisTemplate对象的value序列化
        redisTemplate.setValueSerializer( new StringRedisSerializer()); 

        然后再获取操作对象，进行操作就可以了，注意被序列化的对象要设置JDK序列化版本号不变，不然反序列化回不来哦
        --------------------------------------------------------------
      
        return 向redis添加数据; 
    }
}

区别：
StringRedisTemplate ： 把k，v 都是作为String处理， 使用的是String的序列化 ， 可读性好

RedisTemplate ： 把k，v 经过了序列化存到redis。 k，v 是序列化的内容， 不能直接识别.       // 默认使用的jdk序列化， 可以修改为前提的序列化
                            
 

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

为什么需要序列化：序列化最终的目的是为了对象可以跨平台存储，和进行网络传输。而我们进行跨平台存储和网络传输的方式就是IO，而我们的IO支持的数据格式就是字节数组。我们必须在把对象转成字节数组的时候就制定一种规则（序列化），那么我们从IO流里面读出数据的时候再以这种规则把对象还原回来（反序列化）。

序列化的方式：序列化只是一种拆装组装对象的规则，那么这种规则肯定也可能有多种多样，比如现在常见的序列化方式有：
                                JDK（不支持跨语言）、JSON、XML、Hessian、Kryo（不支持跨语言）、Thrift、Protofbuff、

---

  springboot集成Dubbo

阿里巴巴提供了dubbo集成springBoot开源项目，
可以到GitHub上https://github.com/apache/dubbo-spring-boot-project 查看入门教程 

1. 按照Dubbo官方开发建议，创建一个接口项目（普通maven项目），该项目只定义接口和model类。
2. 创建服务提供者项目（springboot项目）
   1. 额外在springboot引入Dubbo、zookeeper等依赖项：dubbo-spring-boot-starter、dubbo-dependencies-zookeeper、添加接口项目依赖、
   2. 实现接口
   3. 在接口实现类上使用注解暴露出去
      @DubboService(interfaceClass = 接口.class,version = "版本号",timeout="超时时间")
      该注解的interfaceClass属性默认就是实现接口类型      //所以可以不用写
   4. 在接口实现类上使用注解把对象注入容器           //可以不用加该注解，加上了也没影响
      @Component
   5. 在配置文件application.properties

      #配置服务名称     相当于的name属性
      spring.application.name=xxxx
      
      #配置dubbo注解所在的包名   ---->@DubboService
      dubbo.scan.base-packages=包名
      
      #配置dubbo协议
      #dubbo.protocol.name=dubbo
      #dubbo.protocol.prot=端口号
      
      #配置zookeeper注册中心 
      dubbo.registry.address=zookeeper://localhost:2181 
      

   6. 在启动类上加上注解：@EnableDubbo                //启用dubbo
3. 创建消费者项目（springboot项目）
   1. 添加相同的依赖
   2. 编写controller层或者 Service层都可以 ///以controller层为例
   3. 在controller层的类上添加接口类型私有属性，在私有属性上添加注解把对象传过来：
      @DubboReference(interfaceClass = 接口类型.class,version = "版本",check = false)          //引用远程服务，把创建好的代理对象注入给该属性
      该注解的interfaceClass属性默认就是该属性的类型        //所以可以不用写
   4. 在配置文件application.properties

      #配置服务名称     相当于的name属性
      spring.application.name=xxxx
      
      #指定注册中心
      dubbo.registry.address=zookeeper://localhost:2181 
      
      

   5. 在启动类上加上注解：@EnableDubbo                //启用dubbo
4. 启动zookeeper、启用提供者、消费者

---

打包

 Spring Boot 可以打包为 war 或 jar文件。 以两种方式发布应用

使用maven打包：打包成war    --->   maven package     target目录有war文件：xxx.war        tomcat为例， myboot.war放到tomcat/webapps目录----启动Tomcat---浏览器访问web应用

在pom.xml文件

   
   xxx




war

主启动类继承SpringBootServletInitializer:：继承这个类， 才能使用独立tomcat服务器       //SpringBootServletInitializer就是原有的web.xml文件的替代
 

@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);
   }
}

 


打包成jar    同上                
必须maven插件版本

        org.springframework.boot
        spring-boot-maven-plugin
        
        1.4.2.RELEASE

maven package-------target目录有jar文件：mybootjar.jar---------java –jar xxxx.jar执行jar，启动内置的tomcat-----浏览器访问web应用



打包成jar和war的区别：war需要运行在服务器上，jar可以独立运行，内嵌Tocamt

---

Thymeleaf 模板引擎

Spring Boot 集成Thymeleaf模板技术, 使用Thymeleaf代替jsp。               Thymeleaf

Thymeleaf： 是使用java开发的模板技术， 在服务器端运行。 把处理后的数据发送给浏览器。
模板是作视图层工作的。 显示数据的。 Thymeleaf是基于Html语言。 Thymleaf语法是应用在html标签中 。

添加依赖：

 模板引擎可以从request作用域中获取数据 
模板视图文件就是html文件

---

 application.properties设置

#开发阶段设置为false ，上线后设置为 true 
spring.thymeleaf.cache=false 
# 设置模版文件的路径，前缀 
spring.thymeleaf.prefix=classpath:/templates/ 
# 设置后缀 
spring.thymeleaf.suffix=.html 
# 设置模版的类型 
spring.thymeleaf.mode=HTML
#设置模板的格式
spring.thymeleaf.encoding=utf-8

模板文件： 

 
   
 
     
     
 

    
向显示的数据
           使用使用request作用域的数据替换标签的文本内容
------------------------------------------------------------------------------
                      //使用使用request的对象
    
                    //使用对象的属性
    
                //注意该Thymeleaf属性不能超过其对象的作用范围
    

    




------------------------------------------------------------------------------
xxxx

---

字面量

       
文本字面量: 使用单引号括起来的字符串
       
数据显示

       
数字字面量
       
 20大于 5

       
boolean字面量
       
用户已经登录系统

       
null字面量
       
有myuser数据

 字符串连接：        单引号括起来字符串 ， 使用 + 连接其他的字符串或者表达式         

数据显示

                               使用双竖线， |字符串和表达式|                                                       

显示数据

算数运算符： + , - - , * , / , %
关系比较 ： > , < , >= , <=                 ( gt , lt , ge , le )
相等判断： == , !=                             ( eq , ne )
三元运算符：        表达式  ？ true的结果 : false的结果

---

内置对象        

文档地址：Tutorial: Using Thymeleaf.            查看附录18

#request表示HttpServletRequest
#session表示HttpSession对象
session 表示Map对象的， 是#session的简单表示方式， 用来获取session中指定的key的值 -----》 #session.getAttribute("loginname") == session.loginname
这些是内置对象，可以在模板文件中直接使用:

        
内置对象#request,#session，session的使用
        
获取作用域中的数据
        

        

        


        

        

        
使用内置对象的方法
        getRequestURL=

        getRequestURI=

        getQueryString=

        getContextPath=

        getServerName=

        getServerPort=

---

Tymeleaf内置工具类对象                            （文档附录19）

内置工具类型： Thymeleaf自己的一些类，提供对string， date ，集合的一些处理方法

#dates: 处理日器的工具类

#numbers:处理数字的

#lists: 处理list集合的

      
日期类对象 #dates
      

      

      

      

      

      

      

      


      
内置工具类#numbers，操作数字的
      

      


      

      
内置工具类#strings,操作字符串
      

      

      

      

      

      

      

      
 mystring 不是 空字符串  

      

      
内置工具类#lists,操作list集合
      

      
有成员a
      
 list 集合有多个成员

      

      
处理null，加上?当为null是后面的值不取，不然的话取null的属性会报错
      


  

---

自定义模板

模板是内容复用， 定义一次，在其他的模板文件中多次使用。

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

    

        java开发
    
    

        www.baidu.com
    

引用模板：                        //若在不同目录下，文件名称使用---->路径文件名称      如：xxx/xx/文件名称

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功能。