YL工作记录 (不断更新) -- 2020.04

-------------------- 2020.04.07-2020.04.17 --------------------

1. @XStreamAlias理解和使用

- XStream 是个很强大的工具，能将java对象和xml之间相互转化。 XStream不在意java类中成员变量是私有还是共有，也不在乎是否有默认构造函数。

它调用方式也非常简单：从xml对象转化为java对象，使用fromXML()方法；

从java对象序列化为xml，toXML()即可。

一般项目中会有一个XmlUtil工具类，封装了这两个处理方法。

- xstream也支持注解方式，这些都是为了简化输出而设计的。为了告诉XStream框架来处理注释，需要XML序列化之前添加下面的命令: xstream.processAnnotations(Student.class); 或者 xstream.autodetectAnnotations(true);【YL使用的是这种】

- 常用的注解：@XStreamAlias("xxx") // define class/field level alias 给别名
@XStreamAsAttribute("xxx") // define field as attribute 将类内成员作为父节点属性输出
@XStreamImplicit(itemFieldName="xxx") //define list as an implicit collection 集合常用的注解，itemFieldName 说明隐含的元素名,不写默认隐含list变量，
如：List<Ball> Balls上添加注解，会只显示之间的<Ball></Ball>节点元素
@XStreamOmitField("xxx") //omit a field to not to be a part of XML 表明该属性不会被序列化到xml中。

- jar包：xstream-1.4.7 (版本自己根据实际情况选择)，下面是maven依赖（我这边记录为了方便看它属于哪个包里面，方面我在仓库里面快速找到源码去查看） <groupId>com.thoughtworks.xstream</groupId>
<artifactId>xstream</artifactId>

- 特点
1. 简化的API,使用方便 : XStream的API提供了一个高层次外观，以简化常用的用例。
2. 无需创建映射 : XStream的API提供了默认的映射大部分对象序列化。
3. 高性能,低内存占用 : XStream快速和低内存占用，适合于大对象图或系统。
4. 整洁的XML : XStream创建一个干净和紧凑XML结果，这很容易阅读。
5. 不需要修改对象 : XStream可序列化的内部字段，如私有和最终字段，支持非公有制和内部类。默认构造函数不是强制性的要求。
6. 完整对象图支持 : XStream允许保持在对象模型中遇到的重复引用，并支持循环引用。
7. 可自定义的转换策略 : 定制策略可以允许特定类型的定制被表示为XML的注册。
8. 安全框架 : XStream提供了一个公平控制有关解组的类型，以防止操纵输入安全问题。
9. 错误消息 : 出现异常是由于格式不正确的XML时，XStream抛出一个统一的例外，提供了详细的诊断，以解决这个问题。
10.另一种输出格式 : XStream支持其它的输出格式，如JSON。

- 使用场景
Transport 转换
Persistence 持久化对象
Configuration 配置
Unit Tests 单元测试
Interface服务之间XML消息的交互

2. 多线程，参考另外一篇博客：https://blog.csdn.net/qq_36856975/article/details/105467261

3. kryo-1.04.jar

Kryo - Java对象序列化框架 com.esotericsoftware.kryo.Kryo.class

4. MapperScannerConfigurer 作用详解

- 配置mapperScannerConfigurer作用：
负责将mybatis生成的mapper对象放到spring容器里面，Mapper对象是SqlSession.getMapper() 的返回值，即Mapper接口实现

Q1：这边我存在一个疑问：配置mapperScannerConfigurer 这一部分是如何在整合中被省略掉的？？？（我发现fesher/ cloudnote：只要配置了sqlSessionTemplate 就没有配置mapperScannerConfigurer）
【参考来源：https://blog.csdn.net/qq_27771459/article/details/76528081】

5. 序列化（Serializable）

- 什么是Serializable接口
   一个对象序列化的接口，一个类只有实现了Serializable接口，它的对象才能被序列化。
- 什么是序列化？
   序列化是将对象状态转换为可保持或传输的格式的过程。
   与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。
- 为什么要序列化对象
   把对象转换为字节序列的过程称为对象的序列化
   把字节序列恢复为对象的过程称为对象的反序列化
- 什么情况下需要序列化？
1. 当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
2. 当你想用套接字在网络上传送对象的时候；
3. 当你想通过RMI传输对象的时候；
- 关于serialVersionUID的说明，这个值存在怎么定义更合理？？
       为了写入磁盘，再次从磁盘读出时能进行匹配。
       IDEA 和 eclipse都可以在implements Serializable的类里面去自动生成，我建议这样做，虽然JDK文档说生成1L和这种很大的数效果差不多。
    【详细可参考： https://blog.csdn.net/jediael_lu/article/details/26813153
  https://www.cnblogs.com/qq3111901846/p/7894532.html
https://baijiahao.baidu.com/s?id=1633305649182361563】

6. SqlMapConfig.xml文件中的配置总结

1.<settings>全局参数配置
mybatis框架在运行时可以调整一些运行参数，比如：开启二级缓存、开启延迟加载等，有个settings全局参数配置文档：
2.<typeAliases>类型别名、批量别名定义
3.<plugins>配置插件，一般有分页插件
【参考来源： https://www.cnblogs.com/shanheyongmu/p/5849132.html 】

本来只是想理清楚mybatis这个全局配置文件里面，都能（全部有）配置哪些东西。但是后来想再理清楚关于Mybatis的单独配置和 spring集成之后的配置的区别，那么后续慢慢更新中~~~TODO
【打算参考来源（有点像黑马视频教程里的）： https://www.cnblogs.com/shanheyongmu/default.html?page=35 】

7. spring 关于事物

- Spring本身也提供事物管理，可分为：编程式、声明式：xml + 注解
（现在基本上我自己是：在springboot项目中都使用注解的方式去进行事物管理）
- 提供一张我SSM项目中的一张配置图，采用的是xml方式：
通常在applicationcontxt.xml(或者springxxx.xml,名字不一定)里面配置如下图：

可以发现，Spring在jdbc中提供了一个事务管理组件：org.springframework.jdbc.datasource.DataSourceTransactionManager

<!-- 配置事务管理组件 -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource">  <!-- dataSource是数据库连接池 -->
</bean>

使用事务管理的功能，跟创建bean一样，可以采用注解和xml配置两种方式。

<!-- 采用注解方式：有源码的情况下，将注解加在方法上 -->
<!-- 开启事务注解标记@Transactional，当调用带@Transactional标记的方法时，将txManager的事务管理功能切入进去 -->
<tx:annotation-driven transactional-manager="txManager" />
<!-- 在需要事务管理的方法上加上@Transactional注解即可 -->

<!-- 采用xml配置的方式：其实跟上面提供的SSM项目中的一样 -->
<tx:advice id="txAdvice" transaction-manager="txManager" >   <!-- 仍然使用txManager作为事务管理组件 --><tx:attributes><tx:method name="updateTitleAndBody" />   <!-- 在哪些方法上添加事务管理 --><tx:method name="register" />             <!-- 这里写方法名 --><tx:method name="checkLogin" />           <!-- 支持通配符 --><tx:method name="listNotebook" /><tx:method name="getDeletedNotes" /></tx:attributes>
</tx:advice>
<!-- 通过aop机制完成事务管理 -->
<aop:config>      <!-- 作用在哪些组件上 --><aop:pointcut id="target" expression="within(net.sonng.note.service.UserServiceImpl)" /><!-- 这个expression的写法有讲究 --><aop:advisor advice-ref="txAdvice"  pointcut-ref="target"/>
</aop:config>

【参考来源：https://www.cnblogs.com/jpfss/p/8520855.html】

8. Memcached缓存, Memcached与Redis有什么区别?

- memcached是一套分布式的快取系统，与redis相似,当初是Danga Interactive为了LiveJournal所发展的，但被许多软件（如MediaWiki）所使用。这是一套开放源代码软件，以BSD license授权协议发布。
memcached缺乏认证以及安全管制，这代表应该将memcached服务器放置在防火墙后。
memcached的API使用32位元的循环冗余校验（CRC-32）计算键值后，将资料分散在不同的机器上。当表格满了以后，接下来新增的资料会以LRU机制替换掉。由于memcached通常只是当作快取系统使用，所以使用memcached的应用程式在写回较慢的系统时（像是后端的数据库）需要额外的程式码更新memcached内的资料

- Memcached 和 Redis 都是基于内存的数据存储系统。
Memcached是高性能分布式内存缓存服务，其本质上就是一个内存key-value数据库。
Redis是一个开源的key-value存储系统。与Memcached类似，Redis将大部分数据存储在内存中，支持的数据类型包括：字符串、哈希表、链表、集合、有序集合以及基于这些数据类型的相关操作。

- 那么，Memcached与Redis有什么区别呢？让我们一起来看一下。

1、数据操作不同（支持的数据类型和操作性能）
1-1 memcached仅支持简单的key-value
redis 支持的数据类型较多：list、set、sorted set、hash等
1-2 性能：Memcached大大增加了网络IO的次数和数据体积
               Redis中，这些复杂的操作通常和一般的GET/SET一样高效
       与Memcached仅支持简单的key-value结构的数据记录不同，Redis支持的数据类型要丰富得多。
       Memcached基本只支持简单的key-value存储，不支持枚举，不支持持久化和复制等功能。
       Redis支持服务器端的数据操作相比Memcached来说，拥有更多的数据结构和并支持更丰富的数据操作，
       支持list、set、sorted set、hash等众多数据结构，还同时提供了持久化和复制等功能。
       而通常在Memcached里，使用者需要将数据拿到客户端来进行类似的修改再set回去，这大大增加了网络IO的次数和数据体积。
       在Redis中，这些复杂的操作通常和一般的GET/SET一样高效。所以，如果需要缓存能够支持更复杂的结构和操作， Redis会是更好的选择。

  2、内存管理机制不同
redis: 内存 + 物理
Memcached：Slab Allocation机制管理内存   【参考：https://blog.csdn.net/waicyuyan/article/details/79698030】
       在Redis中，并不是所有的数据都一直存储在内存中的。这是和Memcached相比一个最大的区别。
       当物理内存用完时，Redis可以将一些很久没用到的value交换到磁盘。Redis只会缓存所有的key的信息，如果Redis发现内存的使用量超过了某一个阀值，将触发swap的操作，Redis根据“swappability = age*log(size_in_memory)”计算出哪些key对应的value需要swap到磁盘。然后再将这些key对应的value持久化到磁盘中，同时在内存中清除。这种特性使得Redis可以保持超过其机器本身内存大小的数据。
       而Memcached默认使用Slab Allocation机制管理内存，其主要思想是按照预先规定的大小，将分配的内存分割成特定长度的块以存储相应长度的key-value数据记录，以完全解决内存碎片问题。

从内存利用率来讲，使用简单的key-value存储的话，Memcached的内存利用率更高。
而如果Redis采用hash结构来做key-value存储，由于其组合式的压缩，其内存利用率会高于Memcached。

3、性能不同
由于Redis只使用单核，而Memcached可以使用多核，所以平均每一个核上Redis在存储小数据时比Memcached性能更高。
而在100k以上的数据中，Memcached性能要高于Redis，虽然Redis也在存储大数据的性能上进行了优化，但是比起Memcached，还是稍有逊色。

4、集群管理不同
       Memcached是全内存的数据缓冲系统，Redis虽然支持数据的持久化，但是全内存毕竟才是其高性能的本质。
       作为基于内存的存储系统来说，机器物理内存的大小就是系统能够容纳的最大数据量。
       如果需要处理的数据量超过了单台机器的物理内存大小，就需要构建分布式集群来扩展存储能力。

Memcached本身并不支持分布式，因此只能在客户端通过像一致性哈希这样的分布式算法来实现Memcached的分布式存储。
       相较于Memcached只能采用客户端实现分布式存储，Redis更偏向于在服务器端构建分布式存储。

- 小结：Redis和Memcached哪个更好？
       Redis更多场景是作为Memcached的替代者来使用，当需要除key-value之外的更多数据类型支持或存储的数据不能被剔除时，使用Redis更合适。
       如果只做缓存的话，Memcached已经足够应付绝大部分的需求，Redis 的出现只是提供了一个更加好的选择。
       总的来说，根据使用者自身的需求去选择才是最合适的。

- YL是有一个applicationContext-mem.xml的配置文件，里面配置了
           <bean id="memcachedClient" class="net.rubyeye.xmemcached.utils.XMemcachedClientFactoryBean"
                                           destroy-method="shutdown">
               <property name=".."> ..<>
               ..
           </bean>
然后封装CURD等，把memcachedClient注入进去。

【参考来源：https://baike.baidu.com/item/memcached/1625373?fr=aladdin】

9. Spring Http Invoker使用简介

- Invoker 调用程序
Hessian和Burlap都是基于HTTP的，他们都解决了RMI所头疼的防火墙渗透问题。
       但当传递过来的RPC消息中包含序列化对象时，RMI就完胜Hessian和Burlap了。
       因为Hessian和Burlap都是采用了私有的序列化机制，而RMI使用的是Java本身的序列化机制。
       如果数据模型非常复杂，那么Hessian/Burlap的序列化模型可能就无法胜任了。
       Spring开发团队意识到RMI服务和基于HTTP的服务之前的空白，Spring的HttpInvoker应运而生。
       Spring的HttpInvoker,它基于HTTP之上提供RPC,同时又使用了Java的对象序列化机制。

Spring HTTP invoker 是 spring 框架中的一个远程调用模型，执行基于 HTTP 的远程调用（意味着可以通过防火墙），
       并使用 java 的序列化机制在网络间传递对象。这需要在远端和本地都使用Spring才行。
       客户端可以很轻松的像调用本地对象一样调用远程服务器上的对象，这有点类似于 webservice ，但又不同于 webservice ，区别如下：
         ...
       参考里面讲解很好，不需要再赘述了
【参考来源：Spring HTTP Invoker简介   https://www.cnblogs.com/lpc-xx/p/8556827.html
上面就是参考的这个，更详细，但是显得啰嗦   https://www.iteye.com/blog/hanqunfeng-868210，
Spring HttpInvoker入门    https://blog.csdn.net/zl_momomo/article/details/80362002】

-解释：RMI，remoting，远程处理

- YL项目里面没有用Spring Http Invoker，它是自己定义了一个接口，
       /** 这里注意下，抽象方法里面的参数介绍如下：
       *   IoSession，是mian-core-2.0.7.jar org.apache.mina.core.session.IoSession.class
       *   Request/Response 是自己定义封装的对象， extends Message implement
       */
           public interface Invoker{
               WriteFuture invoke(final IoSession session， final Request req， final Response res)
           }

10. MINA，Apache的

YL是 mina-core-2.0.7.jar，(并且 ServerHandler implement IoHandler) ，参考里面几篇都很详细。

-【参考： Apache MINA框架入门，mina框架详解，java开发——Apache Mina的使用，这里整合了spring 】

1.百度百科：Apache Mina是一个能够帮助用户开发高性能和高伸缩性网络应用程序的框架。它通过Java nio技术基于TCP/IP和UDP/IP协议提供了抽象的、事件驱动的、异步的API。
   2.MINA是基于NIO编写的，NIO代表非阻塞IO，BIO代表着阻塞式IO。NIO API是在Java 1.4引入的。
   3.   IoService :     IoAcceptor(Server) +        IoConnector (Client)
                   ScketAcceptor DatagramAcceptor SocketConnector DatagramConnector
               NioSocketAcceptor NioDatagramAcceptor       NioSocketConnector NioDatagramConnector
   4.过程：IoSession -> Filter -> IoHandler

-解释：
     TCP/IP协议是一个协议簇。里面包括很多协议的，UDP只是其中的一个，之所以命名为TCP/IP协议，因为TCP、IP协议是两个很重要的协议，就用他两命名了。
TCP（Transmission Control Protocol，传输控制协议）是面向连接的协议
UDP（User Data Protocol，用户数据报协议）
     套接字Socket=（IP地址：端口号）
   你需要调用IoService 的dispose()方法停止Server 端、Client 端。不然JVM不会关闭

-最后：Netty了解一下？基本把Mina干掉了。。

11.IO：数据 + 流

- 按数据流向分类：输入流和输出流输入流 -> JAVA程序 -> 输出流
按处理的数据类型分类：字节流和字符流

- 二进制文件（图片/音视频）和文本文件（纯文本）
字节流处理字符流处理：字母数字可以字节流，汉字用字符流

- IO字节流：InputStrem和OutputStrem都是接口，不能被实例化。
FileInputStream和FileOutputStrem是它的实现类
   IO字符流：Reader和Writer   接口
InputStreamReader 和 OutputStreamWriter 是它的实现类
       InputStreamReader 创建的时候需要一个字节流，并且提供编码参数
           -> InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"gbk");
   FileReader
           -> FileReader fr = new FileReader(file);
       BufferedReader   字符缓冲输入流,因为是整行读取可以保持格式不乱
           //使用InputStreamReader
           FileInputStream fileInputStream = new FileInputStream(file);
           //获取字符输入流
           InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
           BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
           String line = null;
           while ((line=bufferedReader.readLine())!= null){
               System.out.println(line);
           }
       bufferedWriter   字符缓冲输出流
           FileOutputStream fileOutputStream = new FileOutputStream(file1);
           OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream);
           BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter);
           String line = null;
           while ((line=bufferedReader.readLine())!= null){
               System.out.println(line);
               bufferedWriter.write(line);
               bufferedWriter.newLine();
           }

- 五种IO模型包括：阻塞IO、非阻塞IO、信号驱动IO、IO多路转接、异步IO。其中，前四个被称为同步IO

- 图示

-【参考：死磕Java基础--Java中的I/O流，看这个就够了！ https://blog.csdn.net/sinat_33921105/article/details/81081452
Java IO流详解（面试不要再问我IO流） https://baijiahao.baidu.com/s?id=1659851047751244423】

12. 集合、本来是想主要聊聊Queue的。

- List , Set, Map都是接口，前两个继承至Collection接口，Map为独立接口

Queue,队列
   队列是一种特殊的线性表，特殊之处在于它只允许在表的前端进行删除操作，而在表的后端进行插入操作，亦即所谓的先进先出（FIFO）。
   Java中，LinkedList实现了Deque，可以做为双向队列（自然也可以用作单向队列）。另外PriorityQueue实现了带优先级的队列，亦即队列的每一个元素都有优先级，且元素按照优先级排序。
   - YL：
       AbstractQueue<E> extends AbstractCollection<E> implements Queue<E>
       LinkedBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, Serializable
       LinkedTransferQueue<E> extends AbstractQueue<E> implements TransferQueue<E>, Serializable

【参考：数据结构与算法——常用数据结构及其Java实现 https://www.cnblogs.com/javafirst0/p/10825309.html 后面根据数据结构再补充完整】

13. UUID、MD5加密、BASE64加解密

- UUID，生成32位的随机串：正常结果是xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx，通常去除-

String uuid = UUID.randomUUID().toString().replace("-","");

- MD5加密 + base64加解密
1.MD5加密全程是Message-Digest Algoorithm 5（信息-摘要算法），在Java 8中，Base64编码已经成为Java类库的标准。
2.Base 64主要用途不是加密，而是把一些二进制数转成普通字符，方便在网络上传输。由于一些二进制字符在传输协议中属于控制字符，不能直接传送，所以需要转换一下才可以。由于某些系统中只能使用ASCII字符，Base64就是用来将非ASCII字符的数据转换成ASCII字符的一种方法，Base64特别适合在http，mime协议下快速传输数据。比如网络中图片的传输。
3.两者区别：
       Base64和MD5都可用于做信息的简单加密，两者的简单差别如下：
       Base64：
          1、可逆性。
          2、可以将图片等二进制文件转换为文本文件。
          3、可以把非ASCII字符的数据转换成ASCII字符，避免不可见字符。
       MD5：
          1、不可逆性。
          2、任意长度的明文字符串，加密后得到的密文字符串是长度固定的。
4.code:

import java.security.MessageDigest;//MD5处理
public class MD5 {//获取MD5加密public static String getMd5(String str) {try {MessageDigest md = MessageDigest.getInstance("MD5");md.update(str.getBytes());byte b[] = md.digest();int i;StringBuffer buf = new StringBuffer("");for (int offset = 0; offset < b.length; offset++) {i = b[offset];if (i < 0)i += 256;if (i < 16)buf.append("0");buf.append(Integer.toHexString(i));}str = buf.toString();} catch (Exception e) {e.printStackTrace();}return str;}
}

import java.util.Base64;
import java.util.UUID;
import java.io.UnsupportedEncodingException;
/*** Java 8 内置了 Base64 编码的编码器和解码器。 Base64工具类提供了一套静态方法获取下面三种BASE64编解码器：*  基本：输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。*  URL：输出映射到一组字符A-Za-z0-9+_，输出是URL和文件。*  MIME：输出隐射到MIME友好格式。输出每行不超过76字符，并且使用'\r'并跟随'\n'作为分割。编码输出最后没有行分割。*/
public class Java8Tester {public static void main(String args[]){try {// 使用基本编码String base64encodedString = Base64.getEncoder().encodeToString("runoob?java8".getBytes("utf-8"));System.out.println("Base64 编码字符串 (基本) :" + base64encodedString);// 解码byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);System.out.println("原始字符串: " + new String(base64decodedBytes, "utf-8"));base64encodedString = Base64.getUrlEncoder().encodeToString("runoob?java8".getBytes("utf-8"));System.out.println("Base64 编码字符串 (URL) :" + base64encodedString);StringBuilder stringBuilder = new StringBuilder();for (int i = 0; i < 10; ++i) {stringBuilder.append(UUID.randomUUID().toString());}byte[] mimeBytes = stringBuilder.toString().getBytes("utf-8");String mimeEncodedString = Base64.getMimeEncoder().encodeToString(mimeBytes);System.out.println("Base64 编码字符串 (MIME) :" + mimeEncodedString);}catch(UnsupportedEncodingException e){System.out.println("Error :" + e.getMessage());}}
}

-------------------- 2020.04.13-2020.04.24 --------------------

14.详解java中的四种代码块 (因为在YL方法里面我看到用到了代码块)

在java中用{}括起来的称为代码块，代码块可分为以下四种:
       1.普通代码块/局部代码块,直接定义在方法内部的代码块：控制变量的生命周期，提高内存利用率
       2.静态代码块,static{}：对静态属性、类进行初始化，并且只执行一次。
       3.构造代码块,{}：可以给所有对象进行初始化
       4.同步代码块(多线程)
另.构造方法 public class名(){}
   - 执行顺序：
           静态代码块        ->             构造代码块            ->                    构造方法
       随着类加载，只执行一次       创建一个对象就执行一次，在构造方法之前       创建一个对象就执行一次

15.单点登录(SSO) TODO,有待后续详细理解。

【参考：https://blog.csdn.net/chengzhezhijian 】 - SSO实现原理:1、统一的认证系统 2、票据识别传递(ticket)
1.CAS实现原理
-单点登录SSO的实现方式 https://blog.csdn.net/qq_30788949/article/details/79002652
-评论中，结合oauth2.0实现的sso单点登录系统,与楼主的思路不谋而合：https://github.com/noodlesGood/noodlesGood-SSO

16.泛型：泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法

【参考：https://www.cnblogs.com/coprince/p/8603492.html
java泛型详解 https://blog.csdn.net/s10461/article/details/53941091】

17.spring中的注入相关注解: @Autowired @Qualifier @Resource

1. spring不但支持自己定义的@Autowired注解，还支持几个由JSR-250规范定义的注解，它们分别是@Resource、@PostConstruct以及@PreDestroy。
       -意思是说：@Resource不是spring的。
      2. 当xx接口有多个实现类xx1和xx2，@Autowired注入的时候，它不知道用哪个，此时添加@Qualifier("xx1")就能区分了。
      3. 上面这种情况，使用@Resource(name="xx1")注解就不需要，因为他会根据name参数去找。
      4. 补充：@Resource 可以通过 byName 和 byType的方式注入，默认先按 byName的方式进行匹配，如果匹配不到，再按 byType的方式进行匹配。可以为 @Service和@Resource 添加 name 这个属性来区分不同的实现

spring的bean容器相关的注解有：@Required， @Autowired, @PostConstruct, @PreDestory。
还有Spring3.0开始支持的JSR-330标准javax.inject.*中的注解(@Inject, @Named, @Qualifier, @Provider, @Scope, @Singleton).
springmvc相关的注解有：@Controller，@RequestMapping，@RequestParam， @ResponseBody等等。

18.注解配置

<context:annotation-config/> 开启注解，另：在我们使用注解时一般都会配置扫描包路径选项：
<context:component-scan base-package="pack.pack"/>
其实该配置项其实也包含了自动注入上述processor的功能，因此当使用<context:component-scan/>后，即可将<context:annotation-config/>省去。
【参考： https://www.cnblogs.com/doudouxiaoye/p/5681518.html】

19.Timer.schedule方法的使用

-它属于java.util.Timer定时器, java.util.Timer定时器的常用方法如下：
       schedule(TimerTask task, long delay) // 延迟delay毫秒后，执行一次task。
       schedule(TimerTask task, long delay, long period) // 延迟delay毫秒后，执行第一次task，然后每隔period毫秒执行一次task。
-举例：
       TimerTask task = new TimerTask() {
           @Override
           public void run() {
               // 逻辑处理
           }
       };
       timer.schedule(task, 0); // 此处delay为0表示没有延迟，立即执行一次task
       timer.schedule(task, 1000); // 延迟1秒，执行一次task
       timer.schedule(task, 0, 2000); // 立即执行一次task，然后每隔2秒执行一次task
-Timer的缺陷：基于绝对时间的，对时间的改变非常敏感 + 后台单线程，不支持并发，不会捕获异常。
-具体参考多线程那篇博客的4.7章节。