thead

tbody

tfoot

真实宽高 width height

内边距 padding

边框 border

外边距 margin

左浮动

右浮动

普通文档流定位 (默认)

相对定位

绝对定位

固定定位

parseInt()

parseDouble()

创建一个Servlet实例

初始化数据，可以在we.xml配置

请求和响应处理的方法

结束服务

servlet-->servlet-name,servlet-class servletmapping-->servletname,url-pattern

@WebServlet

1个servlet对应一个 url

.do , .action, .html

/*

/

/* 和 / 的区别 /* 会拦截 .jsp

chain.doFilter(request, response)

ServletRequest

HttpSession

ServletContext

application监听器

session监听器

request监听器

application属性监听器

session属性监听器

request属性监听器

解析过程中

返回的就是一个实现了SqlSessionFactory接口的DefaultSqlSessionFactory对象

最终创建了实现SqlSession接口的DefaultSqlSession对象

autoMappingBehavior

lazyLoadingEnabled

aggressiveLazyLoading

cacheEnabled

logImpl

<typeAlias alias="Author" type="domain.blog.Author"/>

<package name="domain.blog"/>

@Alias("author")

PageHelper原理

<mapper resource="org/mybatis/builder/AuthorMapper.xml"/>

<mapper url="file:///var/mappers/AuthorMapper.xml"/>

<package name="org.mybatis.builder"/>

<mapper class="org.mybatis.builder.AuthorMapper"/>

<resultMap id="rm" type="shoporder"> <id property="sid" column="sid"/> <result property="sname" column="sname"/> <result property="price" column="price"/> <result property="num" column="num"/> <result property="uid" column="uid"/> <association property="user" javaType="user"> <id property="uid" column="uid"/> <result property="uname" column="uname"/> </association> </resultMap> <select id="getAllById" resultMap="rm"> select * from shoporder s,user u where s.uid=u.uid and sid=#{sid} </select>

<resultMap id="rm" type="user"> <id property="uid" column="uid"/> <result property="uname" column="uname"/> <collection property="shoporders" ofType="shoporder"> <id property="sid" column="sid"></id> <result property="sname" column="sname"/> <result property="price" column="price"/> <result property="num" column="num"/> <result property="uid" column="uid"/> </collection> </resultMap>

<resultMap id="rm" type="shoporder"> <id property="sid" column="sid"/> <result property="uid" column="uid"/> <!-- 使用缓存--> <association property="user" javaType="user" select="dao.UserDao.findByUserId" column="uid"/> </resultMap> <select id="getAllById" resultMap="rm"> select sname from shoporder where sid = #{sid} </select>

<select id="findByUserId" resultType="pojo.User"> select * from user where uid=#{id} </select>

<resultMap id="rm" type="user"> <id property="uid" column="uid"/> <result property="uname" column="uname"/> <collection property="shoporders" ofType="shoporder" select="dao.ShoporderDao.getAllById" column="uid"/> </resultMap> <select id="findByUserId" resultMap="rm"> select * from user where uid=#{id} </select>

<select id="getAllById" resultType="shoporder"> select * from shoporder where uid=#{uid} </select>

区别

LRU - 最近最少回收，移除最长时间不被使用的对象(默认)

FIFO - 先进先出，按照缓存进入的顺序来移除它们

SOFT - 软引用，移除基于垃圾回收器状态和软引用规则的对象

WEAK - 弱引用，更积极的移除基于垃圾收集器和弱引用规则的对象

由于二级缓存是应用级缓存，可以跨线线程使用。当不同线程获取到同一个对象时，做不同操作时，就会产生不同的结果相互影响。获取到的对象进行反序列化，获得的对象ID不同，但是对象的值相同，这样不同的操作就不会相互干扰。

不同的session

同session，查询条件不同

同session，查询过程中进行了增删改

调用clearCache手动清除缓存

core和beans模块提供了整个框架最基础的部分，包括了IOC和DI。

Context建立在Core和Beans模块提供的基础之上：他提供了框架式访问对象的方式

core、beans、context构成了Spring的骨架

Expression:提供了一种强大的用于在运行时操作对象的表达式语言

工厂模式

创建bean对象

依赖注入：注入bean和属性

BeanFactory

ApplicationContext

其实它们是同一个概念的不同角度描述

IOC 是通过DI 来实现的，DI 是IOC 实现的手段

普通Bean和工厂Bean

注入外部bean，用ref

注入内部bean，写在properties里

set注入

构造方法注入（以有参构造函数注入）

p 命名空间 注入

当Bean的作用域为singleton的时候,Spring容器中只会存在一个共享的Bean实例

每次对该Bean请求的时候，Spring IoC都会创建一个新的作用域。

Request作用域针对的是每次的Http请求，Spring容器会根据相关的Bean的定义来创建一个全新的Bean实例

针对http session起作用，Spring容器会根据该Bean的定义来创建一个全新的Bean的实例

类似标准的http session作用域，不过仅仅在基于portlet的web应用当中才有意义

调用set方法

创建后置处理器

需要配置初始化方法

需要配置销毁方法

<context:property-placeholder location="url"/>

${key}

<context:component-scan base-package="url"/>

创建bean对象

@Scope

注入属性

@Configuration

@ComponentScan(base-Packages="")

@Bean

@PropertySource

@Import

声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，而编程式事务则需要在代码里进行增加事务代码逻辑

对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务

propagation：事务传播机制

事务隔级别

事务超时

是否只读

rollbackFor

norollbackFor

步骤

步骤

设计原则：开闭原则

有接口

无j接口

JDK动态代理和CGlib的有什么区别?

一个模块化的横切逻辑

某个切面具体执行点(哪些方法可以被增强，这些方法就叫连接点)

连接点的代码逻辑（正则匹配连接方法,实际真正被增强的方法）

被切的、被增强的对象

在执行点上执行的代码逻辑

AOP自动创建，执行增强的方法

切面的过程

导入依赖

切入点表达式

配置方式

也就是我们常说的new

也就是IOC注入

Bean在Spring配置文件中配置了init-method属性会自动调用其配置的初始化方法

使用BeanWrapper

使用BeanFactory

使用ApplicationContext

使用配置文件中的 destory-method 属性

实现 org.springframwork.bean.factory.DisposebleBean接口

springMVC是spring框架的WEB模块

视图(View)-对应组件：JSP或者HTML文件

控制器(Controller)-对应组件：Servlet

模型(Model)-对应组件：JavaBean

MVC优点

MVC缺点

继承FrameworkServlet

getHeader()

getHeaderAdapter()

适配器执行目标方法

分支主题

前端控制器接收到所有请求

前端控制器匹配@RequestMapping，从而找到对应的执行类

前端控制器找到目标类和方法，并返回方法返回值

返回值是一个地址，再由视图解析器解析

前端控制器帮我们转发到指定地址

核心容器

支持注解

日志

web模块

<context:component-scan base-package="com.xmx"/>

配置视图解析器

<servlet> <servlet-name>springmvc</servlet-name> <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class> <!-- 加载Spring MVC配置文件 --> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping>

前端控制器

public class HelloController extends AbstractController { protected ModelAndView handleRequestInternal(HttpServletRequest req, HttpServletResponse resp) throws Exception { System.out.println("进了"); return null; } }

控制器

<servlet> <servlet-name>springmvc</servlet-name> <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class> <!-- 加载Spring MVC配置文件 --> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping>

@RequestMapping("/login") public String hello() { return "login"; }

<mvc:annotation-driven/> <context:component-scan base-package="com.xmx.*" /> <mvc:default-servlet-handler />静态页面，如html,css,js,images可以访问：

<mvc:default-servlet-handler default-servlet-name="所使用的Web服务器默认使用的Servlet名称" />

<mvc:resources mapping="/static/**" location="/static/" />

日志拦截器

拦截请求

要实现拦截器，要继承 HandlerInterceptor

javax.servlet-api

spring-webmvc

spring-tx

aopalliance

aspectjweaver

mysql-connector-java

c3p0

commons-dbcp2

spring-jdbc

mybatis

mybatis-spring

jackson-core

jackson-databind

jackson-annotations

<build> <resources> <resource> <directory>src/main/java</directory> <includes> <include>**/*.xml</include> </includes> </resource> </resources> </build>

配置设置，别名和插件

<context:component-scan base-package="com.xmx.*"/> <!-- 读取数据库配置文件 --> <context:property-placeholder location="classpath:database.properties"/> <!-- 获取数据源(使用dbcp连接池) --> <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close" scope="singleton"> <property name="driverClassName" value="${driver}" /> <property name="url" value="${url}" /> <property name="username" value="${user}" /> <property name="password" value="${password}" /> </bean> <!-- 事务管理 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean> <!-- 配置mybitas SqlSessionFactoryBean--> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <property name="configLocation" value="classpath:mybatis-config.xml"/> <property name="mapperLocations" value="classpath:mapper/*.xml"/> </bean> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="basePackage" value="com.xmx.dao" /> </bean>

<context:component-scan base-package="com.xmx.controller"/> <!--springmvc注解--> <mvc:annotation-driven/> <!--springmvc放行静态资源--> <mvc:resources mapping="/static/**" location="/static/"/> <!--静态页面，如html,css,js,images可以访问--> <mvc:default-servlet-handler/> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" value="/WEB-INF/"/> <property name="suffix" value=".html"/> </bean>

driver=com.mysql.cj.jdbc.Driver url=jdbc:mysql://127.0.0.1:3306/others?useUnicode=true&characterEncoding=utf8&useSSL=false&zeroDateTimeBehavior=CONVERT_TO_NULL&serverTimezone=UTC&allowPublicKeyRetrieval=true user=root password=123456

log4j.rootLogger=DEBUG,CONSOLE,file #log4j.rootLogger=ERROR,ROLLING_FILE log4j.logger.cn.cvs.dao=debug log4j.logger.com.ibatis=debug log4j.logger.com.ibatis.common.jdbc.SimpleDataSource=debug log4j.logger.com.ibatis.common.jdbc.ScriptRunner=debug log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=debug log4j.logger.java.sql.Connection=debug log4j.logger.java.sql.Statement=debug log4j.logger.java.sql.PreparedStatement=debug log4j.logger.java.sql.ResultSet=debug log4j.logger.org.tuckey.web.filters.urlrewrite.UrlRewriteFilter=debug # Console Appender 日志在控制输出配置 log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender log4j.appender.Threshold=error log4j.appender.CONSOLE.Target=System.out log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout log4j.appender.CONSOLE.layout.ConversionPattern=[%p] %d %c - %m%n # DailyRolling File 每天产生一个日志文件，文件名格式:log2009-09-11 log4j.appender.file=org.apache.log4j.DailyRollingFileAppender log4j.appender.file.DatePattern=yyyy-MM-dd log4j.appender.file.File=log.log log4j.appender.file.Append=true log4j.appender.file.Threshold=error log4j.appender.file.layout=org.apache.log4j.PatternLayout log4j.appender.file.layout.ConversionPattern=%d{yyyy-M-d HH:mm:ss}%x[%5p](%F:%L) %m%n log4j.logger.com.opensymphony.xwork2=error

<context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:application-context.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>

<servlet> <servlet-name>springmvc</servlet-name> <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:springmvc-servlet.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping>

logging.level.root=WARN

logging.level.com.lpc=trace

logging.file.path=mylog

logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss.SSS} %contextName [%thread] %-5level %logger{36} - %msg%n

logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} == %contextName == [%thread] %-5level %logger{36} - %msg%n

驱动名

URL指定的驱动程序参数

获取连接时使用的默认身份验证用户名

获取连接时使用的默认身份验证密码

等待来自池的连接的最大毫秒数

控制允许连接在池中闲置的最长时间

连接池支持的最大连接数

连接池中最大空闲连接数

连接池中最小空闲连接数

初始化连接数目

所创建的连接的自动提交（auto-commit）状态

在指定时间间隔里将内存中的数据集快照写入磁盘，恢复时，将快照文件直接读到内存。

1.满足配置里save规则，自动触发

2.执行了flushall,自动触发

3.退出redis,自动触发

1.只需要把rdb文件放到redis的启动目录即可。

2.查看需要存在的位置：config get 目录(该目录存在drump.rdb)

重启redis服务即可生效

protected-mode no

port 6379

daemonize yes

pidfile /var/run/redis_6379.pid

# verbose (many rarely useful info, but not a mess like the debug level)

# debug (a lot of information, useful for development/testing)

# notice (moderately verbose, what you want in production probably)

# warning (only very important / critical messages are logged)

logfile ""

databases 16

always-show-logo no

# save 3600 1

# save 300 100

# save 60 10000

stop-writes-on-bgsave-error no

rdbcompression yes

rdbchecksum yes

dir ./

requirepass foobared xxx

maxclients 10000

maxmemory <bytes>

maxmemory-policy noeviction

appendonly no

appendfilename "appendonly.aof"

# appendfsync always 每次修改都同步，消耗性能

# appendfsync no 不同步，操作系统自己同步数据，速度最快

测试连接

选择数据库

关闭客户端

服务端验证

清空当前数据库

清空所有数据库

关闭服务器

删除key

查询是否存在key，存在返回1，不存在返回0

设置key生效时间（秒）

查询所有的key

返回随机的key

重命名key

字符串追加

自减

减少步长

自增

增加步长

获得key的值

获取key的范围值

设置key值并获取的是key前一个值

设置一个key-value

key不存在，设置key，存在不设置

设置多个key-value

获取多个key的value

对应给定的keys到他们相应的values上。只要有一个key已经存在，MSETNX一个操作都不会执行

返回value的字符串长度

如何解决呢？

分布式锁常见的三种实现方式

这么做的问题是：当有 2 个请求同时更新数据，那么如果不使用分布式锁，将无法控制最后缓存的值到底是多少。也就是并发写的时候有问题

这么做的问题：如果在删除缓存后，有客户端读数据，将可能读到旧数据，并有可能设置到缓存中，导致缓存中的数据一直是老数据。

使用“双删”，即删更删，最后一步的删除作为异步操作，就是防止有客户端读取的时候设置了旧值。
使用队列，当这个 key 不存在时，将其放入队列，串行执行，必须等到更新数据库完毕才能读取数据。

这个实际是常用的方案，但是有很多人不知道，这里介绍一下，这个叫 Cache Aside Pattern，老外发明的。如果先更新数据库，再删除缓存，那么就会出现更新数据库之前有瞬间数据不是很及时。同时，如果在更新之前，缓存刚好失效了，读客户端有可能读到旧值，然后在写客户端删除结束后再次设置了旧值，非常巧合的情况。

有 2 个前提条件：缓存在写之前的时候失效，同时，在写客户度删除操作结束后，放置旧数据 —— 也就是读比写慢。设置有的写操作还会锁表。

所以，这个很难出现，但是如果出现了怎么办？使用双删！！！记录更新期间有没有客户端读数据库，如果有，在更新完数据库之后，执行延迟删除。
还有一种可能，如果执行更新数据库，准备执行删除缓存时，服务挂了，执行删除失败怎么办？？？
这就坑了！！！不过可以通过订阅数据库的 binlog 来删除。

Redis 会将每个设置了过期时间的 key 放入到一个独立的字典中，默认每 100ms 进行一次过期扫描

从库不会进行过期扫描，从库对过期的处理是被动的。主库在 key 到期时，会在 AOF 文件里增加一条 del 指令，同步到所有的从库，从库通过执行这条 del 指令来删除过期的 key

删除指令 del 会直接释放对象的内存，大部分情况下，这个指令非常快，没有明显延迟。不过如果删除的 key 是一个非常大的对象，比如一个包含了千万元素的 hash，又或者在使用 FLUSHDB 和 FLUSHALL 删除包含大量键的数据库时，那么删除操作就会导致单线程卡顿。

unlink 指令，它能对删除操作进行懒处理，丢给后台线程来异步回收内存

配置最大占用

config set maxmemory 100mb

noeviction(默认策略)：对于写请求不再提供服务，直接返回错误（DEL请求和部分特殊请求除外）

allkeys-lru：从所有key中使用LRU算法进行淘汰

volatile-lru：从设置了过期时间的key中使用LRU算法进行淘汰

allkeys-random：从所有key中随机淘汰数据

volatile-random：从设置了过期时间的key中随机淘汰

volatile-ttl：在设置了过期时间的key中，根据key的过期时间进行淘汰，越早过期的越优先被淘汰

当使用volatile-lru、volatile-random、volatile-ttl这三种策略时，如果没有key可以被淘汰，则和noeviction一样返回错误

设置淘汰策略

即最近最少使用，是一种缓存置换算法

Redis使用的是近似LRU算法，它跟常规的LRU算法还不太一样。近似LRU算法通过随机采样法淘汰数据，每次随机出5（默认）个key，从里面淘汰掉最近最少使用的key

  传统构架是部署在一个tomcat上的，Tomcat 默认配置的最大请求数是 150，也就是说同时支持 150 个并发，当某个应用拥有 250 个以上并发的时候，应考虑应用服务器的集群。因此当用户达到一定数量的时候就要考虑到集群。

  通过nginx代理，假设每台服务器能支持150的并发，上面的图中能最大支持300并发。但是配置集群最大的问题就是session共享问题，tomcat的节点越多，它们之间的关系就越复杂。当tomcat集群中节点数量增加，服务能力先增加后下降。所以集群中节点数量不能太多，一般也就5个左右。

根据业务进行拆分，添加服务层

  SOA：Service Oriented Architecture面向服务的架构。也就是把工程拆分成服务层、表现层两个工程。服务层中包含业务逻辑，只需要对外提供服务即可。表现层只需要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。

  把系统按照模块拆分成多个子系统。

优点：

缺点：

一致性

可用性

分区容错性

如果不要求A（可用），相当于每个请求都需要在服务器之间保持强一致，而P（分区）会导致同步时间无限延长(也就是等待数据同步完才能正常访问服务)，一旦发生网络故障或者消息丢失等情况，就要牺牲用户的体验，等待所有数据全部一致了之后再让用户访问系统。设计成CP的系统其实不少，最典型的就是分布式数据库，如Redis、HBase等。对于这些分布式数据库来说，数据的一致性是最基本的要求，因为如果连这个标准都达不到，那么直接采用关系型数据库就好，没必要再浪费资源来部署分布式数据库。

如果要高可用并允许分区，则需放弃一致性。一旦分区发生，节点之间可能会失去联系，为了高可用，每个节点只能用本地数据提供服务，而这样会导致全局数据的不一致性。典型的应用就如某米的抢购手机场景，可能前几秒你浏览商品的时候页面提示是有库存的，当你选择完商品准备下单的时候，系统提示你下单失败，商品已售完。这其实就是先在 A（可用性）方面保证系统可以正常的服务，然后在数据的一致性方面做了些牺牲，虽然多少会影响一些用户体验，但也不至于造成用户购物流程的严重阻塞。

如果不要求P（不允许分区），则C（强一致性）和A（可用性）是可以保证的。但放弃P的同时也就意味着放弃了系统的扩展性，也就是分布式节点受限，没办法部署子节点，这是违背分布式系统设计的初衷的。传统的关系型数据库RDBMS：Oracle、MySQL就是CA。

@EnableEurekaServer

Eureka Server也会注册自己（因此Eureka Server理论上也是一个Eureka Client）

同时每个Eureka Server会定期（默认60s）执行失效服务的检测，当检测到超过一定时间（默认90s）没有发送心跳的客户端，则会注销该客户端的服务节点。

自我保护

两个eureka可以互相注册

@EnableDiscoveryClient

每个Eureka Client会周期性（默认30s）的向Eureka Server发送心跳，已验证该客户端仍然与服务器连接。

来改变周期时间；将其设置为小于30秒，加快客户端连接到其他服务端的过程

在生产中，最好是坚持使用默认，因为在服务器内部有一些计算，它们会对租赁续订期做出一些假设

# 设为false，关闭自我保护主要 eureka.server.enable-self-preservation # 清理间隔（单位毫秒，默认是60*1000） eureka.server.eviction-interval-timer-in-ms

# 开启健康检查（需要spring-boot-starter-actuator依赖） eureka.client.healthcheck.enabled = true # 租期更新时间间隔（默认30秒） eureka.instance.lease-renewal-interval-in-seconds =10        # 租期到期时间（默认90秒） eureka.instance.lease-expiration-duration-in-seconds =30

默认情况下，server在90s之内没有收到client心跳，将我踢出掉。为了让服务快速响应，可以适当地把这个时间改的小一点。

api-client从eureka-server拉取注册表信息是按照defaultZone配置的顺序依次拉取的，当eureka1不可用的时候再从eureka2中获取/注册。但是如果eureka1一直不挂。所有的微服务都会先从eureka1中获取信息，导致eureka1压力过大。在实际生产中，每个微服务可以随机配置不同的defaultZone顺序

api-client会定时到eureka-server拉取注册表。默认情况下每30秒拉取一次。可以根据实际情况设置拉取时间间隔。

非阻塞式

函数式编程端点

Filter在“pre”类型的过滤器可以做参数校验、权限校验、流量监控、日志输出、协议转换等

在“post”类型的过滤器中可以做响应内容、响应头的修改，日志的输出，流量监控等有着非常重要的作用

硬件故障：如服务器宕机，机房断电，光纤被挖断等。

流量激增：如异常流量，重试加大流量等。

缓存穿透：一般发生在应用重启，所有缓存失效时，以及短时间内大量缓存失效时。大量的缓存不命中，使请求直击后端服务，造成服务提供者超负荷运行，引起服务不可用。

程序BUG：如程序逻辑导致内存泄漏，JVM长时间FullGC等。

同步等待：服务间采用同步调用模式，同步等待造成的资源耗尽。

硬件故障：多机房容灾、异地多活等。

流量激增：服务自动扩容、流量控制（限流、关闭重试）等。

缓存穿透：缓存预加载、缓存异步加载等。

程序BUG：修改程序bug、及时释放资源等。

同步等待：资源隔离、MQ解耦、不可用服务调用快速失败等。资源隔离通常指不同服务调用采用不同的线程池；不可用服务调用快速失败一般通过熔断器模式结合超时机制实现。

基于Redis的Session共享方案

拆分多个 queue，每个 queue 一个 consumer，就是多一些 queue 而已，确实是麻烦点；或者就一个 queue 但是对应一个 consumer，然后这个 consumer 内部用内存队列做排队，然后分发给底层不同的 worker 来处理。

提高系统响应速度

提高系统稳定性

吞吐量提升

故障隔离

调用间没有阻塞

耦合度极低

流量削峰

架构复杂了，业务没有明显的流程线，不好管理

需要依赖于Broker的可靠、安全、性能

1个publisher：消息发布者，将消息发送到队列queue

1个queue：消息队列，负责接受并缓存消息

1个consumer：订阅队列，处理队列中的消息

设置上限

exchange负责消息路由，而不是存储，路由失败则消息丢失

Fanout Exchange 会将接收到的消息广播到每一个跟其绑定的queue

Direct Exchange 会将接收到的消息根据规则路由到指定的Queue，因此称为路由模式（routes）

每一个Queue都与Exchange设置一个BindingKey

Exchange将消息路由到BindingKey与消息RoutingKey一致的队列

一个队列可以绑定 多个 RoutingKey

TopicExchange与DirectExchange类似，区别在于routingKey必须是多个单词的列表，并且以 . 分割。

Queue与Exchange指定BindingKey时可以使用通配符： #：代指0个或多个单词 *：代指一个单词

UUID

encode

matches

upgradeEncoding

设置用户名、密码

设置角色

设置权限

自定义登录页

自定义403页面

用户注销

PasswordEncoder

通过并发线程数进行限制

通过响应时间对资源进行降级

普通用户和 root 都可以执行

如用户 liming 的主目录就是 /home/liming

系统建议用来挂载媒体设备，如软盘和光盘

/usr/local/ 目录也可以用来安装软件

普通用户主目录在 /home/ 下，root 主目录直接在“/”下

只有 root 可以使用这些命令进行系统环境设置，但也有些命令可以允许普通用户查看

建议这个目录用来挂载额外的设备，如 U 盘、移动硬盘和其他操作系统的分区

一些系统服务启动之后，可以在这个目录中保存所需要的数据

建议此目录中不能保存重要数据，最好每次开机都把该目录清空

该目录中的数据并不保存在硬盘上，而是保存到内存中

和 /proc/ 目录相似，该目录中的数据都保存在内存中，主要保存与内核相关的信息

显示隐藏文件和可见文件

查看当前目录下所有可见文件的详细属性

输出最后n行的内容，同时监视文件的变化，一旦变化就显示出来

通过git add 状态变为Staged

使用git checkout 则丢弃修改过, 返回到unmodify状态

执行git reset HEAD filename取消暂存, 文件状态为Modified

它被修改, 而变为Modified

LinkedList 是List接口实现类

ArrayList 是List接口实现类

Vector 是List接口实现类

元素可以重复，可以通过索引访问元素

HashSet

TreeSet

元素不可重复,通过迭代器遍历元素,其实大多其底层是包装了一个HashMap去实现的,key作Set的值，而value无用

LinkedHashMap

WeakHashMap

基于哈希表实现，非线程安全

非线程安全基于红黑树实现

HashMap<String,Integer> map=new HashMap<>(); map.put("a",1); map.put("b",2); map.put("c",3); map.put("d",4); Set set=map.keySet(); Iterator iterator=set.iterator(); while (iterator.hasNext()){ String key= (String) iterator.next(); System.out.print(key+map.get(key)+" "); }

HashMap<String,Integer> map=new HashMap<>(); map.put("a",1); map.put("b",2); map.put("c",3); map.put("d",4); Iterator iterator=map.entrySet().iterator(); while (iterator.hasNext()){ Map.Entry<String,Integer> entry= (Map.Entry<String, Integer>) iterator.next(); System.out.print(entry.getKey()+entry.getValue()+" "); }

资源一次只被一个线程使用

请求资源被阻塞后，对以获得资源不释放

未使用完之前，不允许被剥夺资源

头尾相接的循环等待资源关系

事务A读取到事务B未提交的数据

事务A读取两次，数据不一样（第二次读事务A读取了事务B已提交修改后的数据和第一次不一致）

事务A重新执行查询，返回的行中有事务B提交的行

1.读未提交

2.读已提交

3.可重复读

4.可串行化

这里的相等是指，通过equals()比较两个对象时返回true

这是因为虽然p1 和 p2的内容相等，但是它们的hashCode()不等；所以，HashSet在添加p1和p2的时候，认为它们不相等。

Object类的构造方法

可以命名任何你想要你的C函数

用来另存一个当前存在的对象。只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常

该方法返回的是此Object对象的类对象/运行时类对象Class

用来比较两个对象的内容是否相等

返回其所在对象的物理地址（哈希码值）

返回该对象的字符串表示

导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法

超过指定的时间量

其他某个线程中断当前线程，或者已超过某个实际时间量

唤醒在此对象监视器上等待的单个线程

唤醒在此对象监视器上等待的所有线程

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法

实现Comparator接口，重写compare方法

实现comparable接口，重新compareTo方法

集体实现类

具体实现

工厂类对实现同一接口的类进行实例化（在一个方法内）

工厂类里多个方法分别对实现同一接口的类进行实例化

工厂类里多个静态方法分别对实现同一接口的类进行实例化，工厂方法直接调用

区别于普通简单工厂，把工厂做成接口，多个工厂实现类

抽象工厂像工厂，工厂方法像产品生产线

定义

实现

类型

以y一个对象为原型，对其进行复制和克隆，产生和原对象类似的 新对象

把类的接口转化成客户端期望的接口

JVM栈

本地方法栈

Java栈的区域很小,特点是存取速度很快， 所以在stack中存放基本数据类型的数据，和对象的引用

类的对象放在heap（堆）中，所有的new 出的东西都放在堆中。

method区 存放所有的 1 类的字节码文件，2 静态变量（static变量），3 方法的模板。

程序计数器用来记录当前正在执行的指令.

1.用户自定义加载器

2.启动类（根boot）加载器

3.扩展类(ext)加载器 jre/lib/ext/

4.应用程序(app)加载器 jre/rt.jar

AppClassLoader 向上委托了两次，即“双”，“亲”代表亲人的意思,对双亲的理解

内存中加载的数据量过于庞大，如一次从数据库取出过多数据；

集合类中有对对象的引用，使用完后未清空，使得JVM不能回收；

代码中存在死循环或循环产生过多重复的对象实体；

使用的第三方软件中的BUG；

启动参数内存值设定的过小；

第一步，修改JVM启动参数，直接增加内存。(-Xms，-Xmx参数一定不要忘记加。)

第二步，检查错误日志，查看“OutOfMemory”错误前是否有其它异常或错误。

第三步，对代码进行走查和分析，找出可能发生内存溢出的位置。

引用计数法

复制算法

根搜索算法

标记清除法

标记压缩整理

分代收集

强引用

软引用

弱引用

虚引用

先不初始化单例，等第一次使用的时候再初始化，即“懒加载”

好处是更启动速度快、节省资源，一直到实例被第一次访问，才需要初始化单例

小坏处是写起来麻烦，大坏处是线程不安全，if语句存在竞态条件

最粗暴的犯法是用synchronized关键字修饰getInstance()方法，这样能达到绝对的线程安全。

好处是写起来简单，且绝对线程安全

坏处是并发性能极差，事实上完全退化到了串行

性能不敏感的场景建议使用。

变种2是“臭名昭著”的DCL 1.0。

针对变种1中单例初始化后锁仍然无法避开的问题，变种2在变种1的外层又套了一层check，加上synchronized内层的check，即所谓“双重检查锁”（Double Check Lock，简称DCL

DCL仍然是线程不安全的，由于指令重排序，你可能会得到“半个对象”，即”部分初始化“问题

变种3专门针对变种2，可谓DCL 2.0。

instance上增加了volatile关键字

多线程环境下，变种3更适用于性能敏感的场景

存储字符串'abc'

事务A读取到事务B未提交的数据

事务A读取两次，数据不一样（第二次读事务A读取了事务B已提交修改后的数据和第一次不一致）

事务A重新执行查询，返回的行集合中有事务B提交的行

1.读未提交

2.读已提交

3.可重复读

4.可串行化

MyISAM索引文件和数据文件是分离的，索引文件仅保存数据记录的地址，按照B+Tree搜索算法搜索索引，如果指定的Key存在，则取出其data域的值，然后以data域的值为地址，读取相应数据记录。

InnoDB的数据文件本身就是索引文件，这棵树的叶节点data域保存了完整的数据记录，InnoDB的辅助索引data域存储相应记录主键的值而不是数据记录地址，首先检索辅助索引获得主键，然后用主键到主索引中检索获得记录

分支主题

有n棵子树的节点含有n个关键字（也有认为是n-1个关键字）。

所有的关键字全部存储在叶子节点上，且叶子节点本身根据关键字自小而大顺序连接。

非叶子节点可以看成索引部分，节点中仅含有其子树（根节点）中的最大（或最小）关键字

分支主题

以左表为基准，左表全显示，右表匹配就显示，否则显示null

以右表为基准，右表全显示，左表匹配就显示，否则显示null

数据库自增 id

设置数据库 sequence 或者表自增字段步长

好处就是本地生成，不要基于数据库来了；不好之处就是，UUID 太长了、占用空间大，作为主键性能太差了；更重要的是，UUID 不具有有序性，会导致 B+ 树索引在写的时候有过多的随机写操作（连续的 ID 可以产生部分顺序写），还有，由于在写的时候不能产生有顺序的 append 操作，而需要进行 insert 操作，将会读取整个 B+ 树节点到内存，在插入这条记录后会将整个节点写回磁盘，这种操作在记录占用空间比较大的情况下，性能下降明显

适合的场景

问题是，并发很高的时候，比如一秒并发几千，会有重复的情况，这个是肯定不合适的。基本就不用考虑了

适合的场景

是 twitter 开源的分布式 id 生成算法