服务端开发-1-复习汇总

1. 服务端开发-1-复习汇总

2. 第一节：概述

2.1. Spring是Java生态圈的主流编程框架

1. 轻量级（Lightweight）
2. 非侵入性（No intrusive）
3. 容器（Container）
4. 依赖注入(Dependency Injection)
5. 面向切面编程(Aspect Oriented Programming)
6. 持久层（JDBC封装、事务管理、ORM工具整合）
7. Web框架（MVC、其它WEB框架整合）
8. 其他企业服务的封装

2.2. Spring 的模块组成

2.3. 经典的基于Spring的典型Web分层架构示例

3. 第二节：依赖注入 —— Spring容器

3.1. Spring配置方案

1. Spring框架负责创建对象和建立之间的关系
2. 配置方法(告知Spring配置方案)
   1. XML：最早
   2. 自动化配置
   3. JavaConfig

3. 创建上下文方式：
   1. Config文件 + 注解
   2. XML实现配置

3.2. auto(section2-1)

1. @componentScan：声明扫描包内的Component，进行对应的实例化。
   1. 等价于：
   2. 无参数：扫描当前文件所在包
   3. 有参数：
      1. 不安全的：({“包名”, “包名”})
      2. 类型安全：(basePackageClasses = xxx.class)表示扫描该类所在的包
      3. marked interface：保证类型的安全，同时保证类的重构不影响它，在这个类底下添加一个稳定的接口(标签接口)
2. @component：告知框架，当前类需要实例化，等价于@Named
3. @Autowired：自动装配(注入)，可以放在构造函数、setter上，等价于@Inject
   1. 构造对象的时候调用构造函数或者setter
   2. required参数：默认为true，可以修改为false表示允许该值为null
   3. 不必与@Bean同时使用，加上@Bean的方法的参数可以自动注入
   4. 可能涉及到的POM配置文件如下

<dependency>
    <groupId>javax.injectgroupId>
    <artifactId>inject-apiartifactId>
    <version>1.0.0-PRDversion>
dependency>



<dependency>
    <groupId>javax.injectgroupId>
    <artifactId>com.springsource.javax.injectartifactId>
    <version>1.0.0version>
    <scope>providedscope>
dependency>

5. Spring的命名空间、XML文件配置法(:命名空间)

3.3. JavaConfig(section2-2)

1. 没有@Component，依靠在Config中编写，是基于Java的配置
2. @configuration：声明一个配置类，告知框架读取配置
3. @Bean(name="xxx")：声明一个Bean，并且可以自定义名称
   1. Bean的默认名称为方法名
   2. 可以通过name字段修改bean的名称
   3. 可以有多个
4. Bean的实例个数
   1. 单实例(默认)：默认情况下多次调用创建多实，默认在一个容器里面。
   2. 多实例
   3. 使用@Scope进行修改：Scope，也称作用域，在Spring IoC容器是指其创建的 Bean 对象相对于其他 Bean 对象的请求可见范围。在 Spring IoC 容器中具有以下几种作用域：
      1. 基本作用域：
         1. singleton表示在spring容器中的单例，通过spring容器获得该bean时总是返回唯一的实例
         2. prototype表示每次获得bean都会生成一个新的对象(多实例)
      2. Web作用域
         1. request表示在一次http请求内有效(只适用于web应用)
         2. session表示在一个用户会话内有效(只适用于web应用)
            1. 会话建立时创建Bean，会话结束后销毁Bean
            2. Session Client和Server之间的一个Session，不同Client可能和Server建立多个Session，Request是一次请求和处理
         3. globalSession表示在全局会话内有效(只适用于web应用)：请求开始时创建Bean，请求结束后销毁Bean
      3. 自定义作用域

// 使用会话和请求作用域
@Component
@Scope(value=WebApplicationContext.SCOPE_SESSION,
       proxyMode=ScopedProxyMode.INTERFACES)
public ShoppingCart cart(){....}

5. 一般情况下配置类和业务类会分包存储。

3.4. XML(section2-3)

1. bean:
   1. 不能进行类型检查
   2. 有构造函数参数(构造器注入)
      1. 元素：每个参数一条
         1. 引用:
         2. 值:
      2. 属性：
         1. c-命名空间
         2. 建议按顺序取：编译结束后名称就已经不存在了
      3. 注入具体值
         1. 指定字面量值：(表示null)
         2. 指定集合：和，中间的值为xxx
   3. 属性方式注入(p name)
      1. set方式名字和properties name保持一致
      2. p命名空间不支持list
      3. 可以存放多项，然后p引用该util(util命名空间)

<bean>
   <property name=".."  ref=".."/>
bean>
<property name="..">
   <list>
      <value>
   list>
property>
<util:list id="...">
   <value>xxxvalue>
util:list>

2. xml文件名和测试类的名字一样，就不需要在测试的上下文配置中指定。
3. 强依赖建议使用构造器注入

3.5. 混合(section2-4)

1. 混合配置：
   1. JavaConfig：类型检查简单
      1. @Import(配置类.class, xxx)
      2. @ImportResource(xml文件)
   2. xml：导入、.class文件不用调整
2. 配置文件(java 和 xml)里面可以import别人
3. import可以import多个：xml里面，配置类写过的可以不仔细写

3.6. 控制容器实例化

3.6.1. @Profile

1. @Profile：不同情况下使用不同的bean，使用profile来控制，还可以使用Spring Boot的属性文件命名(含后缀)
   1. dev
   2. prod
2. 激活：激活的方式使用激活的三种方式。Spring Boot在java –jar时，使用-Dspring.profiles.active =sys会读取application-sys.properties文件来完成配置。如果没有添加profile则会帮你实例化出来（无论是否有profile的别的）
   1. spring.profiles.default="dev"
   2. spring.profiles.active="prod"
   3. @ActiveProfiles("dev")

package com.myapp;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
import org.springframework.jndi.JndiObjectFactoryBean;
import javax.sql.DataSource;
@Configuration
public class DataSourceConfig {
    @Bean(destroyMethod = "shutdown")
    @Profile("dev") // 开发环境
    public DataSource embeddedDataSource() {
        return new EmbeddedDatabaseBuilder()
                .setType(EmbeddedDatabaseType.H2)
                .addScript("classpath:schema.sql")
                .addScript("classpath:test-data.sql")
                .build();
    }
    @Bean
    @Profile("prod") //W生产环境
    public DataSource jndiDataSource() {
        JndiObjectFactoryBean jndiObjectFactoryBean = new JndiObjectFactoryBean();
        jndiObjectFactoryBean.setJndiName("jdbc/myDS");
        jndiObjectFactoryBean.setResourceRef(true);
        jndiObjectFactoryBean.setProxyInterface(javax.sql.DataSource.class);
        return (DataSource) jndiObjectFactoryBean.getObject();
    }
}

3.6.2. @Conditional

1. Conditional的**.class实现了Condition接口，自己决定什么时候创建这个Bean，什么时候不创建这个Bean

@Bean
@Conditional(xxx.class)

public class xxx implements Conditonal{
   boolean matches(){...}
}

3.6.3. 自动装配的歧义性

1. @Component 或 @Bean
2. @Primary
3. 定义时
   1. @Componet或@Bean
   2. @Qualifier("...") 自定义限定符，通过使用@Qualifier注解，我们可以消除需要注入哪个bean的问题。
4. 使用时
   1. @Autowired
   2. @Qualifier("…") bean名称或自定义限定符，默认Bean名是限定符
5. Spring 注解 @Qualifier 详细解析
6. 可以自定义注解，这些注解本身也加了@Qualifier注解
   1. @Cold
   2. @Creamy

@Qualifier
public @interface cold{
}

3.6.4. 通过代理注入给单例对象

@Component
public class StoreService{ 
   // 单实例，注入每一个人创建的每一个购物车
   // Spring如何把一个会话范围的对象注入到一个单例对象中呢？Spring实际上注入的是一个代理对象
   // 最开始注入的时候Spring注入了一个代理对象，如果一开始是A的购物车，那么就会讲代理对象和对应的A的Bean对应起来
   @Autowired
   public void setShoppingCart(ShoppingCart shoppingCart){}
   // StoreService是单例对象
   // ShoppingCart是接口
   // shoppingCart是会话范围的对象
}

4. 面向切面编程 AOP

4.1. 概述

1. AOP：Aspect Oriented Programming
2. 发展史：
   1. POP：面向过程编程
   2. OOP：面向对象编程
   3. AOP：面向切面编程
   4. FP：函数式编程
   5. Rx：反应式编程(Java 9、Spring 5)

4.2. 概念

1. 横切关注点：切入的代码的功能或者关注点，业务代码不关注这部分点
   1. 日志
   2. 安全
   3. 事务
   4. 缓存
2. 通知(Advice)：切面做什么？什么时候做？代表了切面的逻辑。
3. 切点(Pointcut)：指定通知存放的位置，定义要改的方法和参数。
4. 切面(Aspect)：通知 + 切点
5. 连接点：通知 + 切点的实例化：也就是和业务代码连接的地方
6. 引入(Introduction)：(给对象)引入新的行为和状态
7. 织入(weaving)：切面应用到目标对象的过程

4.2.1. 通知类型

1. @Before：在调用目标之前
2. @After：被切的对象方法执行之后，等于@AfterReturnning + @AfterThrowing
3. @AfterReturning：被切对象方法返回后，有异常但是没有return的话不执行AfterReturning
4. @AfterThrowing：被切对象方法出现异常之后
5. @Around：被切对象方法的执行前和执行后，等于@Before + @After

4.2.2. 织入的时机

1. 编译器：编译的时候将Aspect织入进去，需要使用特别的编译器。
2. 类加载期：Spring不支持
3. 运行期(Spring 织入)：使用代理对象，就是获得的是切面对象的代理对象的引用，通过代理来操作，只支持方法级别的连接点

4.2.3. Spring AOP的两种支持类型

1. @ApectJ注解驱动的切面
   1. 切面表达式：表达切点
   2. 流程：写@Aspect->配置Config完成实例化和代理配置
   3. 多参数
   4. 语法：
      1. 对参数不感兴趣：√
      2. 对返回值或方法名不感兴趣：×
   5. 参考

// AspectJ 切点指示器（pintcut designator）

@Pointcut("execution(*com.springinaction.springidol.Performer.perform(..))")

&& within(concert1.*)
&& bean(concert2)

&& args(trackNumber)

2. 纯POJO切面：通过XML而不是Spring注解，解决：比如想要将第三方无源码代码织入。
3. 开启AspectJ的自动代理机制：@EnableAspectJAutoProxy

4.2.4. 引入新功能

1. @DeclareParents：使用代理的方式为原类增加新方法，参考
2. main 和 测试

4.2.5. XML中声明切面

1. 前置和后置通知
3. 声明环绕通知
4. 传参数，测试
5. 引入新功能

5. Web

5.1. 软件系统结构(C/S B/S)

1. C/S(Client)：客户机和服务器(有客户端，相当于安装软件)
2. B/S(Browser)：浏览器和服务器

5.2. 分层结构

1. 控制层：Controller
2. 业务层：Service(业务逻辑)
3. 持久化层(DAO)：repository(数据库访问)
   1. view层
   2. model层
   3. domain层(领域层)：把Java对象对应到数据库里的表

5.3. Spring MVC请求

1. 第一步：携带有URL和表单信息的Request达到DispatchServlet
2. 第二步：DispatchServlet去Handler mapping中查找映射关系
3. 第三步：根据查找到的映射关系，将Request交给具体对应的Controller
4. 第四步：Controller得到携带的URL和表单信息等，在交给业务层处理后，得到业务层返回的Model和logical的视图名
5. 第五步：DispatchServlet得到对应的model和logical view name(str)，并向ViewResolver根据名称查找界面
6. 第六步：DispatchServlet得到查找到的View界面
7. 第七步：将View放置在Response中返回给客户端

5.4. DispatchServlet的配置

1. Servlet3规范
2. 使用Java将DispatchServlet配置到Servlet容器中
3. 自定义DispatchServlet需要实现WebApplicationInitializer接口，或其实现接口
   1. AbstractAnnotationConfigDispatcherServletInitializer实现了WebApplicationInitializer接口
      1. DispatcherServlet加载的应用上下文：getServletConfigClasses，装载Web组件：控制器、视图解析器、处理器映射
      2. ContextLoaderListerner加载的应用上下文：getRootConfigClasses，装载其它Bean

5.5. 常见的上下文文件

1. web.xml
2. applicationContext.xml
3. 相对比较传统

5.6. 启用Spring MVC组件

1. 注解@EnableWebMvc
2. 配置视图解析器
3. 启动组件扫描
4. 排除静态资源的请求

5.7. 检验表单

1. Java检验API(Java Validation API)
   1. @NotNull
   2. @Size
   3. @Valid
2. 检查回调结果

// 注意参数Errors必须紧跟在带有@Valid注解的参数后面
@RequestMapping(value = "/add", method = RequestMethod.POST)
public String savePerson(@Valid Person person, Errors errors) throws Exception {
   if (errors.hasErrors()) {
      return "personForm";
   }
}

5.8. 前后端分离和前后端不分离

前后端不分离	前后端分离

5.9. 文件上传

1. AbstractAnnotationConfigDispatcherServletInitializer中需要配置registration.setMultipartConfig(new MultipartConfigElement)
2. WebMvcConfigurerAdapter中需要配置StandardServletMultipartResolver
3. 控制器：@RequestPart("file") MultipartFile file
4. 页面指定表单格式：multipart/form-data

5.10. 异常处理

1. 抛出异常与响应状态关联

@ResponseStatus(value = HttpStatus.NOT_FOUND, reason = "Not Found")
public class SpittleNotFoundException extends RuntimeException {}

2. 异常与响应页面的关联

@ExceptionHandler(DuplicateSpittleException.class)
public String handleNotFound() {
   return "error/duplicate";
}

3. 为控制器添加通知

@ControllerAdvice
public class AppWideExceptionHandler {
   @ExceptionHandler(DuplicateSpittleException.class)
   public String handleNotFound() { return "error/duplicate"; }
}

4. 跨重定向请求传递数据：自学7章

6. 第五章：Spring Security

6.1. 过滤web请求

1. 新开了一个WebApplicationInitializer实现，用于拦截请求
   另一个WebApplicationInitializer是AbstractAnnotationConfigDispatcherServletInitializer（仅负责DispatcherServlet的初始化）
   这两个同时存在

6.2. 安全配置

@Configuration
@EnableWebMvcSecurity // 打开Spring Security
public class SecurityConfig extends WebSecurityConfigurerAdapter {
   // 配如何通过拦截器保护请求
   void configure(HttpSecurity http)

   // 配用户数据存储 内存、数据库表
   void configure(AuthenticationManagerBuilder auth)
}

1. @EnableWebMvcSecurity相比于@EnableWebSecurity，增加：
   1. @AutthenticationPrincipal注解的参数解析，获得用户名
   2. 增加一个bean，页面自动添加CSRF token输入域
   3. 注意SecurityConfig与SecurityWebInitializer是两个不同的类

6.3. 拦截请求

1. 使用HTTPS安全通道
2. 防止跨站请求伪造，cross-site request forgery，CSRF
   1. 默认开启
   2. 关闭：.csrf().disable()
3. 登录页面
   1. formLogin
   2. loginPage
4. 启用HTTP Basic认证
   1. httpBasic()
   2. 关于Cookie
5. 启用Remember-me功能
6. rememberMe()
7. 退出
   1. Filter自动拦截/logout请求
   2. 重定向

6.4. 建立HTTPS安全通道

1. 访问链接
2. 总结来说就是服务端tomcat要配keystore，里面也有客户端的证书，客户端windows系统里也要有客户端证书，服务端证书ca。

keytool -genkey -v -alias mytomcat -keyalg RSA -keystore mytomcat.keystore -validity 36500
# "keytool -importkeystore -srckeystore mytomcat.keystore -destkeystore mytomcat.keystore -deststoretype pkcs12" 行业标准格式
keytool -genkey -v -alias myclient -keyalg RSA -storetype PKCS12 -keystore myclient.p12
keytool -export -alias myclient -keystore myclient.p12 -storetype PKCS12 -storepass Workflow21 -rfc -file clientforserver.cer  导出来给服务端用的
keytool -import -v -file clientforserver.cer -keystore mytomcat.keystore
keytool -list -keystore mytomcat.keystore
keytool -keystore mytomcat.keystore -export -alias mytomcat -file ca.cer  导出来给客户端用的

6.5. CSRF攻击

6.6. 保护视图

1. JSP标签库
2. Thymeleaf方言：templateEngine.addDialect(new SpringSecurityDialect());，pom依赖如下

<dependency>
   <groupId>org.thymeleaf.extrasgroupId>
   <artifactId>thymeleaf-extras-springsecurity3artifactId>
   <version>2.1.1.RELEASEversion>
dependency>

6.7. 保护方法的配置

@EnableGlobalMethodSecurity(securedEnabled=true)
public class SecuredConfig extends GlobalMethodSecurityConfiguration {}

1. @EnableGlobalMethodSecurity(securedEnabled=true)应该可以放到WebSecurityConfigurerAdapter
2. 就是WebSecurityConfigurerAdapter与GlobalMethodSecurityConfiguration合二为一
3. 这样请求拦截和方法保护同时有效

6.8. 三种安全注解

1. spring自带注解
   1. @Secured({"ROLE_SPITTER", "ROLE_ADMIN"})
   2. securedEnabled=true
2. JSR-250
   1. @RolesAllowed("ROLE_SPITTER")
   2. jsr250Enabled=true
3. 表达式驱动的注解
   1. @PreAuthorize("(hasRole('ROLE_SPITTER') and #spittle.text.length() le 140) or hasRole('ROLE_PREMIUM')")
   2. @PostAuthorize
   3. @PreFilter
   4. @PostFilter
   5. prePostEnabled=true

7. 第六章：ORM与Hibernate、JPA编程

7.1. ORM

1. ORM：对象关系映射(Object-Relational-Mapping)，在Java对象和关系型数据库之间的映射，实现直接存取Java对象，只是一套规范
   1. 在Java对象与关系数据库之间建立某种映射，以实现直接存取Java对象；不必编写RowMapper，不用关系对象是如何获得的，也不用担心一对多等问题
2. 具体实现
   1. Hibernate、MyBatis
   2. JPA (Java Persistence API)

7.2. Hibernate

7.2.1. Hibernate配置

1. org.hibernate.Session接口
2. 获取org.hibernate.SessionFactory对象：org.springframework.orm.hibernate4.LocalSessionFactoryBean
3. 定义映射关系：XML、注解(JPA、Hibernate)

7.2.2. Hibernate的三类查询

1. HQL(Hibernate Query Language)：即Hibernate提供的面向对象的查询语言
   1. select/update/delete
   2. from
   3. where
   4. group by
   5. having
   6. order by
   7. asc/desc
2. QBC(Query By Criteria)：完全面向对象的查询
3. 本地SQL

7.3. @Repository注解

1. 类似于@Component
2. 转换成Spring的统一异常，实现持久化异常转换的Bean

@Bean
public BeanPostProcessor persistenceTranslation(){
   return new PersistenceExceptionTranslationPostProcessor();
}

7.4. JPA Java Persistence API

1. JPA: Java持久化 API，为POJO提供持久化标准规范
2. JPQL(Java Persistence Query Language)：类似SQL
3. JPQL就是一种查询语言，具有与SQL相类似的特征
4. 参考

7.4.1. JPA配置

1. javax.persistence.EntityManager：类似于Hibernate的Session
2. 实体管理器工厂(Entity Manager Factory)
   1. org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean
   2. org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter
3. 并不真正注入EntityManager
   1. 线程不安全，每次操作前创造一个
   2. @PersistenceUnit：每个EntityManager负责将固定数量的一组类映射到数据库中，这组类就被称做persistence unit。Persistence unit是在persistence.xml中定义的。根据Java Persistence规范的要求，该部署描述文件是必需的。一个persistence.xml文件可以定义一个或多个persistence unit，它一般都会放置在META-INF目录中。
   3. @PersistenceContext：称为持久化上下文，它一般包含有当前事务范围内的，被管理的实体对象(Entity)的数据。每个EntityManager，都会跟一个PersistenceContext相关联。PersistenceContext中存储的是实体对象的数据，而关系数据库中存储的是记录。
4. 应用程序管理类型：LocalEntityManagerFactoryBean persistence.xml配置持久化单元、数据源
5. 容器管理类型：LocalContainerEntityManagerFactoryBean adapter背后可以有不同厂家的JPA实现
6. pom依赖

<dependency>
   <groupId>org.springframework.datagroupId>
   <artifactId>spring-data-jpaartifactId>
   <version>1.3.2.RELEASEversion>
dependency>

7. JPA配置
   1. 加注解@EnableJpaRepositories：会扫描org.springframework.data.repository.Repository接口
   2. 继承接口org.springframework.data.jpa.repository.JpaRepository
   3. 可以继承org.springframework.data.repository. CrudRepository：包含18个方法

7.4.2. 编写自定义的查询方法

1. 定义查询方法，无需实现
   1. 领域特定语言（domain-specific language，DSL)，spring data的命名约定
   2. 查询动词 + 主题 + 断言
   3. 查询动词：get、read、find、count
2. 声明自定义查询
   1. 不符合方法命名约定时，或者命名太长时
   2. @Query("select ...")
3. 使用EntityManager直接低层实现：接口名+Impl的实现类

7.5. JPA、Hibernate、Spring Data JPA三者之间的关系

7.6. 例子：在Spring Boot开发中使用MyBatis

1. application-xxx.yml中的配置
   1. 配置数据源
   2. mapper-locations指定mapper文件地址

spring:
   datasource:
      driverClassName: "org.sqlite.JDBC"
      url: "jdbc:sqlite::memory:"
      initialization-mode: always
      schema: classpath:schema-sqlite.sql

2. 定义接口(使用注解@Mapper)
3. 映射文件地址:classpath:mapper/***Mapper.xml

7.7. JDBC

1. 业务访问与持久化解耦
   1. 数据访问对象(DAO)或者Repository
   2. 业务对象 -> Repository接口 <- Repository实现(依赖倒置)
2. 异常处理：SQLException
   1. 非"运行时异常"，注意catch
   2. 链接断开、语法有误会导致这个异常
   3. 难以恢复、难以确定类型
   4. Spring：把异常变成运行时的DataAccessException(平台无关，让DAO层的异常不会被业务层直接发现)
3. 模板方法模式：定义过程的主要框架，template
   1. 资源管理
   2. 事务控制
   3. 异常管理
4. 配置数据源方法
   1. JNDI数据源：Java命名与目录接口
      1. Web容器(比如Tomcat)中配置JNDI参数，定义一个数据源(XML文件方式)
      2. 以Tomcat为例：在conf目录下的server.xml
      3. 驱动程序放到lib里面。
   2. 直接在Spring里面使用连接池化处理
      1. 很多第三方软件可以重用
      2. 可以在Java里或XML配置
      3. DBCP
   3. Spring 提供：JDBC驱动
      1. DriverManagerDataSource：没有连接池
      2. SingleConnectionDataSource：只有一个连接
      3. 开发或测试使用
   4. 用Spring配置嵌入式数据源:
5. @Profile("dev")：配置环境，用来决定不同环境下选择哪一个进行实例化
   1. @ActiveProfile：指定当前环境
   2. 不改变源代码
6. RowMapper的接口的实现：lamada表达式负责将数据库字段映射到java对象的属性
7. 持续交付-部署流水线：共用一套测试版本，加入到制品库后的东西不能够重新编译添加。

8. 第八章：非关系型数据库和编程

1. MongoDB：文档式的存储。
2. Redis：集群间的数据共享、缓存。
3. 非关系型数据库不要求定义Schema，存储方式可以是多种多样的。

8.1. NoSQL

1. NoSQL(Not Only SQL)：指非关系型的数据库
2. 没有声明性查询语言
3. 没有预定义的模式
4. 键-值对存储、列存储、文档存储、图形数据库

命令	解释
db.help()	help on db methods
db.mycoll.help()	help on collection methods
sh.help()	sharding helpers
rs.help()	replica set helpers
help admin	administrative help
help connect	connecting to a db help
help keys	key shortcuts
help misc	misc things to know
help mr	mapreduce
show dbs	show database names
show collections	show collections in current database
show users	show users in current database
show profile	show most recent system.profile entries with time >= 1ms
show logs	show the accessible logger names
show log [name]	prints out the last segment of log in memory, ‘global’ is default
use	set current database
db.foo.find()	list objects in collection foo
db.foo.find( { a : 1 } )	list objects in foo where a == 1
it	result of the last line evaluated; use to further iterate
DBQuery.shellBatchSize = x	set default number of items to display on shell
exit	quit the mongo shell

8.2. MongoDB

8.2.1. 简介

1. C++编写，基于分布式文件存储的开源数据库系统
   1. 文档存储一般采用JSON格式
   2. 存储的内容是文档型，保证了有机会对某些字段创建索引
   3. 里面的对象自带时间属性

docker run --name mymongo -d -p 27017:27017 mongo
docker stop mymongo
docker rm mymongo

mongo访问
docker run -it --link mymongo:my_tag --rm mongo mongo --host my_tag

docker network create my-network
docker run --net=my-network --name mymongo -d mongo 
docker run --net=my-network  -it  --rm mongo mongo --host mymongo

2. MongoDB Shell是它自带的Shell，Js的Shell，可以在里面敲JS
3. 术语：
   1. database=database
   2. collection=table
   3. document=row
   4. field=column
   5. 同一个Collection中的Document的Field可以不相同
4. 文档：
   1. 一次记录中有多个对象，要用另一张表Join，但是Mongo里可以存在一起
   2. 嵌套.pretty()显示的更格式化更好看

8.2.2. 编程

1. 基于JDBC驱动：启动一个MongoDB的Client，获得DataBase，数据库操作，Close，和Spring本身没有关系

@EnableMongoRepositories(basePackages = "customers.db")
org.springframework.data.mongodb.repository.MongoRepository

2. 推荐工具：Java-Faker
3. Spring Data MongoDB
   1. 需要添加Spring Data的依赖，包含类的时候可以直接存储
   2. 数据结构的定义注解是@Document，当前的数据类作为一个Document
   3. @MongoRepository：带参数、类名和ID类型。
   4. @Query(json)：筛选条件
      1. save会将class字段自动添加进入
4. 不同插入方式的效率问题
   1. Java-Faker：构造数据使用(需要添加依赖)
   2. JDBC快：Spring Data插进去了更多的字段

8.3. Redis

8.3.1. 简介

1. key-value的Hash结构，存的是数据结构
   1. key-value是大小写。
   2. 可以指定key的消亡时间。
2. 内存数据库(缓存)
3. 可以做集群部署，master-slave结构，写给master，然后由master复制给slave们
   1. 集群环境下事务的处理
   2. 集群环境下Message的处理、消息队列
4. key-value可以区分大小写。
5. 可以查看数据类型
   1. string：如果发现是数值类型也可以做数值计算
   2. list：链表，往left或者right插入
      1. 可以阻塞等待，设置等待时间
      2. push和pop
      3. 阻塞等待：BRPOP和BLPOP
   3. hash：hm set key
   4. set

8.3.2. 编程

1. 连接Redis：
   1. 需要客户端连接
   2. 创建连接工厂(RedisConnectionFactory)，提供Template模板(RedisTemplate、StringRedisTemplate)，Factory不指定则使用默认的连接(6379端口)
2. 要实现一个序列化接口
   1. 不推荐使用基于Java的序列化(字节序列)
   2. 比如换成jackson、json格式等
3. RedisTemplate的子API
   1. 使用简单的值：opsForValue() - ValueOperations，set、get
   2. 使用List类型的值：opsForList() - ListOperations：rightPush、leftPop、range
   3. 在Set上执行操作
      1. opsForSet() - SetOperations
      2. add、difference、union、intersect
   4. 绑定到某个key上：boundListOps(“cart”)
4. 指定序列化器
   1. 默认处理：JdkSerializationRedisSerializer
   2. StringRedisSerializer
   3. Jackson2JsonRedisSerializer

9. 第九章：缓存编程

9.1. 概述

1. 添加一层缓存，常用到的数据可以不从数据库中查找
2. 启用缓存
   1. @各种注解，在Repository层的接口中添加
   2. 配置类里面添加@EnableCaching
   3. 缓存管理器：Spring默认提供(org.springframework.cache.CacheManager)，但是一般用第三方
3. 利用AOP机制，在方法前后进行处理。

9.2. 缓存实现

1. (原生的)定义一个Bean，返回一个ConcurrentCacheManager
   1. org.springframework.cache.concurrent.ConcurrentMapCacheManager
   2. CacheEvict：从缓存中也删除。
2. EhCache：速度比较快
   1. org.springframework.cache.ehcache.EhCacheCacheManager
   2. 和程序运行在同一个进程内，提供一些额外的功能。
3. RedisCache：分布式
   1. org.springframework.data.redis.cache.RedisCacheManager
   2. 3个Bean：模板、工厂、Manager
   3. 本地需要启动Redis

9.3. EhCache

1. 概念：
   1. CacheManager：Cache的容器对象，并管理着(添加或删除)Cache的生命周期。
   2. Cache：一个可以包含多个Element，由CacheManager管理，实现缓存的逻辑。
   3. Element：需要缓存的元素，维护键值对，可以设置有效期(0代表无限制)，可以包含多个信息。
2. 初始化Manager的时候需要XML配置，需要引入pom的引入，使用XML进行配置(XML中包含了每个Cache的配置)
3. 使用Spring：
   1. import EhCache的包
   2. 使用工厂来完成实例化

9.3.1. 自定义缓存配置

1. name : 缓存的名称，可以通过指定名称获取指定的某个Cache对象
2. maxElementsInMemory ：内存中允许存储的最大的元素个数，0代表无限个
3. clearOnFlush：内存数量最大时是否清除
4. eternal ：设置缓存中对象是否为永久的，如果是，超时设置将被忽略，对象从不过期。
5. timeToIdleSeconds ： 设置对象在失效前的允许闲置时间（单位：秒）
6. timeToLiveSeconds ：缓存数据的生存时间（TTL）
7. overflowToDisk ：内存不足时，是否启用磁盘缓存
8. maxEntriesLocalDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。maxElementsOnDisk：硬盘最大缓存个数
9. diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区
10. diskPersistent：是否在VM重启时存储硬盘的缓存数据。默认值是false
11. memoryStoreEvictionPolicy：如果内存中数据超过内存限制，向磁盘缓存时的策略。默认值LRU，可选FIFO、LFU。

9.3.2. Spring 与 EhCache的集成

1. pom依赖配置

<dependency>
   <groupId>net.sf.ehcachegroupId>
   <artifactId>ehcacheartifactId>
   <version>2.7.4version>
dependency>
<dependency>
   <groupId>net.sf.ehcachegroupId>
   <artifactId>ehcache-jcacheartifactId>
   <version>1.4.0-beta1version>
dependency>

2. 配置CacheManager

@Bean
public EhCacheCacheManager cacheManager(CacheManager cm) {
   return new EhCacheCacheManager(cm);
}

9.3.3. Spring 与 Redis 集成

1. pom依赖

<dependency>
   <groupId>net.sf.ehcachegroupId>
   <artifactId>ehcacheartifactId>
   <version>2.7.4version>
dependency>
<dependency>
   <groupId>net.sf.ehcachegroupId>
   <artifactId>ehcache-jcacheartifactId>
   <version>1.4.0-beta1version>
dependency>

2. 配置CacheManager

@Bean
public CacheManager cacheManager(RedisTemplate redisTemplate) {
   return new RedisCacheManager(redisTemplate);
}

9.4. 缓存注解

1. @Cacheable：先去缓存中查找，如果没有找到则去数据库中查找，并将结构缓存，参数是Cache的名字
   1. condition：缓存条件，可以禁用缓存
   2. unless：阻止引入
2. @CachePut：在数据库中粗出后将结果放入到缓存，而不会进数据库中找
3. @CacheEvict：从Cache中删除，beforeInvocation，调方法之前就删除

9.5. 自定义缓存Key

1. SpEL表达式中的元数据
   1. #result：结果对象
   2. #Argument：参数对象
2. 可以指定，使用元数据
3. 条件化缓存
   1. 属性condition 禁用缓存
   2. 属性unless 阻止将对象放进缓存

10. 第十章：Docker

10.1. 容器与虚机

10.2. Docker 组成

1. 容器是在Linux内核实现的轻量级隔离机制
   1. 虚拟机是操作系统级别的资源隔离
   2. 容器本质上是进程级的资源隔离，是共用主机内核，利用内核的虚拟化技术隔离出一个独立的运行环境，拥有独立的一个文件系统、网络空间和进程空间视图

2. 组成
   1. Docker Daemon(Docker Engine)：一般在宿主主机后台运行
   2. 用户使用Client和Engine(Daemon)交互，可以通过pip、unix socket、tcp进行交互
   3. Docker Index指向Docker registries，也叫Docker仓库，也叫做Docker仓库，可以用来上传和下载images，官方docker仓库:Hub.docker.com
3. 使用GO语言实现

10.3. 虚拟机与容器

1. 从虚拟化层看容器，轻量级、高性能是核心价值：虚拟机 vs 容器
   1. 容器是在Linux内核实现的轻量级资源隔离机制
   2. 虚拟机是操作系统级别的资源隔离，容器本质上是进程级的资源隔离

10.4. 使用

1. run
   • -d：后台运行容器，并返回容器ID
   • -i：以交互模式运行容器，通常与-t同时使用
   • -t：为容器重新分配一个伪输入终端，通常与-i同时使用
   • -p：指定(发布)端口映射，格式(主机(宿主)端口:容器端口)
   • -P：随机端口映射，容器内部端口随机映射到主机的高端口
   • –name = “docker_name”：为容器指定一个名称
   • -e env=“value”：设置环境变量
   • –env-file=“filename”：从指定文件中读入环境变量
   • –expose=2000-2002：开放(暴露)一个端口或一组端口
   • –link container_name:tag_name：添加链接到另一个容器，对于某个容器，跑的时候给要连接的另一个容器添加一个名字，就可以把那个容器映射到当前容器里
   • -v path_name：绑定一个卷(volumn)
   • –rm：退出时自动删除容器
2. container
   • docker container ls
   • docker container ls -a
   • docker container ls -aq
   • docker inspect 容器名：显示容器信息
   • docker port 容器名：显示端口映射信息
   • docker logs -f 查看容器内部的标准输出
   • docker stop 停止一个容器
   • docker start 启动已停止运行的容器
   • docker restart 正在运行的容器可以重启
   • docker attach 附着到容器
   • docker exec -it /bin/bash 进入容器，执行命令
   • docker rm -f 删除容器
   • docker container prue：清理掉所有处于终止状态的容器

10.5. Volumn

1. 镜像分层
   1. 镜像顶层可读写，底层不可写
   2. 写时复制：如果需要进行读写，进行提升

2. 数据卷(volume：Docker管理宿主机文件系统的一部分，默认位于/var/lib/docker/volumns目录中)
   1. Docker 管理卷：docker volumn 命令
   2. 绑定挂载卷：-v，挂载到容器内
   3. bind mounts:意味着可以存储在宿主机系统的任意位置
   4. tmpfs：挂载存储在宿主机系统的内存中

# docker volume create edc-nginx-vol // 创建一个自定义容器卷 
# docker volume ls // 查看所有容器卷
# docker volume inspect edc-nginx-vol // 查看指定容器卷详情信息
docker inspect -f {{.Mounts}} b1
#docker volume rm edc-nginx-vol // 删除自定义数据卷
创建使用指定卷的容器
docker run -d --name=edc-nginx -p 8800:80 -v edc-nginx-vol:/usr/share/nginx/html nginx   注意：-v 后面只有一个目录名，则指的是在容器中目录，然后会自动创建一个volume与它对应。如果edc-nginx-vol不存在，则会自动创建一个volume
docker run -d  --name=edc-nginx -v /app/wwwroot:/usr/share/nginx/html nginx

docker rm -v 命令在删除容器时删除该容器的卷
docker volume prune

docker cp c:/temp1 first:/data    在主机与容器之间COPY
docker cp first:/data  /tmp

10.6. 导出和导入容器镜像

docker export 1e560fca3906 > ubuntu.tar
# 导出容器 1e560fca3906 快照到本地文件 ubuntu.tar
docker import ubuntu.tar test/ubuntu:v1
# 将快照文件 ubuntu.tar 导入到镜像 test/ubuntu:v1
docker import http://example.com/exampleimage.tgz example/imagerepo

10.7. 容器网络

1. docker bridge：所有的容器都联通到桥上，彼此间就可以连通。
   1. 桥有自己的网关，可以路由到虚拟机的网卡上，虚拟机又可以路由到外面的宿主机
   2. 两个虚拟机之间可以用overlay打通。
   3. 不建议挂载bridge上，因为需要--link才能彼此连通。
2. 容器网络
   1. none网络，–net=none
   2. host网络，–net=host
   3. bridge网络，–net=bridge，docker0 的 linux bridge
   4. container模式，–net=container:NAME_or_ID
3. host：容器本身没有网卡，使用的是宿主机的网络。
4. 使用自己创建的网络
   1. 同一个网络下的各个容器，可以通过容器名直接连通
   2. 也可以到达虚拟机的网卡，连接宿主机
5. 自己创建的网络和真实的网络是一样的
6. 一个容器可以有多个网卡(IP地址)

connect  NETWORK CONTAINER    Connect a container to a network
create      Create a network
disconnect  NETWORK CONTAINER  Disconnect a container from a network
inspect     Display detailed information on one or more networks
ls          List networks
prune       Remove all unused networks
rm          Remove one or more networks
docker network create my-network
docker run --net=my-network --name mymongo -d mongo 
docker run --net=my-network  -it  --rm mongo mongo --host mymongo
# Docker 挂载网络

11. 微服务

11.1. 单体 VS 微服务

1. 单体应用程序
   1. 数据库的表对所有模块可见
   2. 一个人的修改整个应用都要重新构建、测试、部署
   3. 整体复制分布式部署，不能拆分按需部署
2. 微服务
   1. 应用程序分解为具有明确定义了职责范围的细粒度组件
   2. 完全独立部署、独立测试，并且可以服用
   3. 使用轻量级通信协议(HTTP和JSON)，松耦合
   4. 服务实现可使用多种编程语言和技术
   5. 将大型团队划分成多个小型开发团队，每个团队只负责他们各自的服务。

11.2. 开发技术

1. 针对Java开发：Spring Boot和Spring Cloud
   1. Spring Boot：拿到开发具体的微服务，面向REST的微服务框架
   2. Spring Cloud：解决实施和部署微服务到私有云和公有云的问题。
2. REST原则：表现层状态转化(Representational State Transfer)
   1. 资源(Resources)：网络上的一个实体，比如图、文档等等，标识为URI
   2. 表现层(Representation)：可以认为是View，展现资源
   3. 状态转化(State Transgfer)：服务端 —— 客户端
   4. HTTP协议的四个操作动词：Get、Post、Put、Delete
   5. CRUD：Create Read Update Delete
   6. 如果一个架构符合REST原则，就称它为RESTful架构

11.3. 客户端与服务的交互

11.3.1. 请求头与请求体

1. 请求头：请求头由 key/value 对组成，每行为一对，key 和 value 之间通过冒号(:)分割。请求头的作用主要用于通知服务端有关于客户端的请求信息。
   1. User-Agent：生成请求的浏览器类型
   2. Accept：客户端可识别的响应内容类型列表；星号* 用于按范围将类型分组。*/*表示可接受全部类型，type/*表示可接受 type 类型的所有子类型。
   3. Accept-Language: 客户端可接受的自然语言
   4. Accept-Encoding: 客户端可接受的编码压缩格式
   5. Accept-Charset： 可接受的字符集
   6. Host: 请求的主机名，允许多个域名绑定同一 IP 地址
   7. connection：连接方式（close 或 keepalive）
   8. Cookie: 存储在客户端的扩展字段
   9. Content-Type:标识请求内容的类型
   10. Content-Length:标识请求内容的长度
2. 请求体：请求体主要用于 POST 请求，与 POST 请求方法配套的请求头一般有 Content-Type和 Content-Length

11.3.2. 响应头与响应体

1. 状态行：由 HTTP 协议版本、状态码、状态码描述三部分构成，它们之间由空格隔开。
2. 状态码：由 3 位数字组成，第一位标识响应的类型，常用的5大类状态码如下：
   1. 1xx：表示服务器已接收了客户端的请求，客户端可以继续发送请求
   2. 2xx：表示服务器已成功接收到请求并进行处理
   3. 3xx：表示服务器要求客户端重定向
   4. 4xx：表示客户端的请求有非法内容
   5. 5xx：标识服务器未能正常处理客户端的请求而出现意外错误
3. 响应头
   1. Location：服务器返回给客户端，用于重定向到新的位置
   2. Server：包含服务器用来处理请求的软件信息及版本信息Vary：标识不可缓存的请求头列表
   3. Connection: 连接方式，close 是告诉服务端，断开连接，不用等待后续的请求了。keep-alive 则是告诉服务端，在完成本次请求的响应后，保持连接
   4. Keep-Alive: 300，期望服务端保持连接多长时间（秒）
4. 响应内容：服务端返回给请求端的文本信息。

11.3.3. 客户端表述的两种方式

1. 内容协商（Content negotiation）
   1. ContentNegotiatingViewResolver是要创建的bean，基于内容协商生成表述，判断的依据有请求头的Accept，URL请求路径加扩展名（优先）。
   2. 然后会转向具体的视图解析器生成不同的视图表述
   3. ContentNegotiationManager（配置的作用）
      1. 通过setter注入到ContentNegotiatingViewResolver中
      2. 创建这个Bean的方式是继承自WebMvcConfigerAdapter（基于spring mvc）
      3. 覆盖方法configureContentNegotiation，配置缺省内容类型等。
   4. 缺点：不能处理request输入(消息转换)
2. 消息转换器（Message conversion）
   1. 使用注解@ResponseBody或类级@RestController，作用：指定使用消息转换器
   2. 没有model和视图，控制器产生数据，然后消息转换器转换数据之后的资源表述。
   3. spring自动注册一些消息转换器（HttpMethodConverter），不过类路径下要有对应转换能力的库，如：Jackson Json processor、JAXB库
   4. 请求传入，@RequestBody以及HttpMethodConverter

11.3.4. 提供资源以外的其他内容

1. @ResponseStatus(HttpStatus.CREATED)指定返回的状态码
2. 控制器方法返回ResponseEntity对象，指定业务对象（负载）、状态码、响应头：不用使用@ResponseBody注解
3. 异常处理器，@ExceptionHandler（异常类型），加在方法上
4. 指定响应头信息，通过返回ResponseEntity对象的方式
   1. HttpHeaders类型：注意与发出请求时的类型MultiValueMap区别
   2. setLocation

@RequestMapping(value = "/ab/ab", method = RequestMethod.GET, produces = "application/json")public ResponseEntity<String> bar() {
   final HttpHeaders httpHeaders= new HttpHeaders();
   httpHeaders.setContentType(MediaType.APPLICATION_JSON);
   return new ResponseEntity<String>("{\"test\": \"jsonResponseExample\"}", httpHeaders, HttpStatus.OK);
}

11.3.5. REST客户端

1. new RestTemplats()
2. getForObject()，指定返回类型，自动转换
3. getForEntity()，返回ResponseEntity,有头部信息，getBody()可以转换
4. put()，传递的对象存在转换问题，String转成test/plain，MultiValueMap转成x-www-form-urlncoded，对象可能转成json，要看classpass类路径下有无库。
5. delete（），删除一个资源，一般提供资源路径即可
6. postForObject()/postForEntity()/postForLocation
   1. 因为需要返回值
   2. postForLocation，只需要路径，不需要body，路径信息来源头部Location信息
7. exchange(),可指定请求头信息
   1. MultiValueMap headers
   2. HttpEntity