捷配欢迎您!
微信扫一扫关注我们
当前位置：&>>&&>>&&>>&存储器知识大科普
&&& 是记忆信息的实体，是数字计算机具备存储数据和信息能力，能够自动连续执行程序，进行广泛的信息处理的重要基础。
　　1存储器的概念
　　（1） 存储器：存储器是计算机硬件系统的记忆设备，用来存放程序（软件）和各种数据。现在计算机硬件系统的核心就是存储器和CPU
　　（2） DMA：一种可以让存储器与IO设备进行数据存取的方式。设计理念就是为了在IO设备与存储器进行数据存取时不去打扰CPU。
　　2存储器的分类
　　（1） 按照存储器的介质分类：
　　1.1 半导体存储器：由半导体组成的存储器称为半导体存储器，半导体的存储器体积小，功率低，存取时间短。但是消失时，所存储的数据也会丢失，是一种易失性存储器；
　　1.2 磁材料存储器：由磁材料做成的存储器称为磁性存储器，在金属或塑料上涂抹一层，用来存放数据，特点是非易失即断电后不数据不消失，存取速度比较慢；
　　1.3 盘存储器：光盘存储器使用激光在磁光材料上进行读取，特点是非易失性，耐用性好，记录密度高。现在多用在计算机系统中用作外部存储。
　　（2） 按照存储器的数据存取方式分类：
　　2.1 随机存储器（Random Access
RAM）：RAM（随机存储器）是一种可以读可以写的存储器，它的任何一个存储单元的内容都可以随机存取，而且存取的时间与物理位置无关，我们的内存（主存）就是这种RAM（随机存储器）；
　　2.2 只读存储器（Read
Memory ROM）：ROM（只读存储器）是一种只能写入一次原始信息，写入之后，只能对去内部的数据进行读出，而不能随意重新写入新的数据去改变原始信息；
　　2.3 串行访问数据存储器：在对存储器的存储单元进行读写操作时，必须要按照存储单元的物理位置先后寻址地址，这种存储器就为串行访问存储器。这种存储器在存取数据时，需要按照存储器的存储单元的位置显示进行存取。
　　（3） 按照其在计算机系统中的作用：
　　3.1 主存储器（主存）：通常指我们所说的内存，它可以直接与CPU交换数据的存储器，特点速度快，容量小，价格高。主存采用半导体制作，所以是易失性存储器；
　　3.2 辅助存储器（辅存）：通常指我们所说的外存，用来存放当前没有使用的程序和数据，它不能直接与CPU交换数据，需要加载到主存。特点速度慢，容量大，价格便宜。辅存属于非易失性存储器；
　　3.3 缓冲存储器（缓存）：主要用到俩个速度不同的部件之中，现在基本用在CPU与主存之间，起到缓存的作用。
　3存储器的层次
　　（1） 存储器的层次按照它的3个指标即速度，容量，每位价格进行划分分别是：
　　寄存器=》缓存=》主存=》磁盘=》光盘
　　越是上层的存储器它的容量越小，速度越快，每位价格越高，越是下层的存储器容量越大，速度越慢，每位价格越低。
　　寄存器是CPU中的一个存储器CPU实际上是拿寄存器中的数进行运算和控制，它的速度最快，价格最高。
　　缓存也被设置到了CPU中。
　　（2） 缓存与主存主要是为了解决CPU与主存速度不匹配的问题，因为CPU速度要快与主存，而缓存也快与主存，只要将CPU近期要使用的数据调入到缓存中，CPU直接从缓存中获取数据，来提升数据的访问速度，降低CPU的负荷。主存与缓存的数据调动是由硬件自己完成的。
　　（3） 主存与辅存主要用来解决存储系统的容量问题，辅存比主存速度低，并且不能被CPU之间访问，但它容量大，当CPU需要运行程序时，将辅存的数据调入到主存，CPU在来访问。主存和辅存之间的数据调动由硬件和操作系统共同完成。
　　功能：主存储器是能由CPU直接编写程序访问的存储器，它存放需要执行的程序与需要处理的数据，只能临时存放数据，不能长久保存数据。
　　组成：
　　● 存储体（MPS）：由存储单元组成（每个单元包含若干个储存元件，每个元件可存一位二进制数）且每个单元有一个编号，称为存储单元地址（地址），通常一个存储单元由8个存储元件组成；
　　● 地址寄存器（MAR）：由若干个触发器组成，用来存放访问寄存器的地址，且地址寄存器长度与寄存器容量相匹配（即容量为1K，长度无2^10=1K）；
　　● 地址译码器和
　　● 数据寄存器（MDR）：数据寄存器由若干个触发器组成，用来存放存储单元中读出的数据，或暂时存放从数据来的即将写入存储单元的数据【数据存储器的宽度（w）应与存储单元长度相匹配】。
　　主要技术指标：
　　● 存储容量：一般指存储体所包含的存储单元数量（N）；
　　● 存取时间（TA）：指存储器从接受命令到读出M写入数据并稳定在数据寄存器（MDP）输出端；
　　● 存储周期（TMC）：两次独立的存取操作之间所需的最短时间，通常TMC比TA长；
　　● 存取速率：单位时间内主存与外部（如CPU）之间交换信息的总位数；
　　● 可靠性：用平均故障间隔时间MTBF来描述，即两次故障之间的平均时间间隔。
　　5高速缓冲存储器（缓存）：
　　1）高速缓冲存储器的设计理念：为了解决由于IO设备向主存请求的级别高于CPU向主存请求，也就是说IO设备在使用主存时，CPU要等待IO设备访存，导致 CPU工作效率降低，可以在CPU与主存之间加一级缓存，这样CPU可以从缓存中获取数据，另外主存的速度要低于CPU，缓存也是为了解决这俩个硬件设备 速度不匹配的问题。
　　2）程序访问的局部性：即程序的数据和指令在主存中是连线存放的，并且有些指令和数据往往被多次调用，循环什么的，这样CPU在访问主存时只要将近期需要使用的数据和指令放到Cache中，就可以在一定时间内一直访问Cache，称缓存命中。
　　3）缓存的工作原理：将主存和缓存分成若干个块，每个块存储的容量都是相同的，任何时刻都有一些主存的块处在缓存块中，可以将缓存当成主存的一个映射，CPU在读取主存的某个字时都会先去缓存中访问，有二种可能，一是缓存中有当前字，CPU直接访问（CPU与缓存通常一次传送一个字）称为缓存命中；另一种是所需的字不在cache中，此时需要将该字所在的主存整个块一次调入Cache中（缓存与主存是按照字块传送）称为缓存不命中。
　　4）主存与缓存之间数据的调入是由机器硬件自动完成的，用户编程时使用的只是主存地址，也就是说cache对我们来说是透明的。
　　5）我们平时在写程序时所说的缓存指的是主存到辅存（或者说是内存到硬盘之间设立一个类似于缓存的区域）来减少磁盘的IO提升性能，而这里的缓存指的是CPU与主存之间的。
　　6ROM与RAM
　　RAM（随机存储器）可读出，也可写入，随机存取，意味着存取任一单元所需的时间相同，当断电后，存储内容立即消失，称为易失性。
　　ROM（只读存储器）定义：ROM一旦有了信息，不易改变，结构简单，所以密度比可读写存储器高，具有易失性
　　分类：
　　● 固定掩模型ROM（不能再修改）
　　● PROM可编程之读存储器（由用户写入，但只允许编程一次）
　　● 可擦除可编程只读存储器（可用紫外线照射擦除里面内容）
　　● E2PROM电擦除可编程只读存储器（由电便可擦除里面内容）
7辅助存储器（外存）：
　　（1） 辅存概念与设计理念：辅助存储器主要为了给主存提供程序和数据的输入和用来在计算机脱机时保存所有的计算机数据。属于非易失性存储器，通常辅存也称为外存，由硬磁盘和软磁盘，磁带，光盘等。形成了主辅层次存储器。
　　（2） 硬磁盘（硬盘）：现在计算机采用的辅存多采用硬磁盘（硬盘），即在一组圆形的盘面上涂抹磁性材料。通过这个硬盘的运作和进行读写，磁头划的一个圈称为磁道，硬盘存取数据时是直接存取的，分为俩部分一是找到相应的磁道，然后是磁头开始读写。
　　（3） 硬盘组成：硬盘由磁盘驱动器，磁盘控制器，盘片组成
　　磁盘分区表（partition table）：
　　利用参考对照磁柱号码的方式来切割硬盘分区！ 在分割表所在的64 bytes容量中，总共分为四组记录区，每组记录区记录了该区段的启始与结束的磁柱号码。若将硬盘以长条形来看，然后将磁柱以直条图来看，那么那64 bytes的记录区段有点像底下的图示：
　　上图中我们假设硬盘只有400个磁柱，共分割成为四个分割槽，第四个分割槽所在为第301到400号磁柱的范围。
　　由于分割表就只有64 bytes而已，最多只能容纳四笔分割的记录，这四个分割的记录被称为主要（Primary）或延伸（Extended）分割槽。根据上面的图示与说明，我们可以得到几个重点资讯：
　　● 其实所谓的『分割』只是针对那个64 bytes的分割表进行配置而已！
　　● 硬盘默认的分割表仅能写入四组分割资讯《主要分割与扩展分配最多可以有四条（硬盘的限制）》；
　　● 这四组分割资讯我们称为主要（Primary）或延伸（Extended）分割槽；
　　● 扩展分配最多只能有一个（操作系统的限制）；
　　● 逻辑分割是由扩展分配持续切割出来的分割槽，如果扩展分配被破坏，所有逻辑分割将会被删除；
　　● 能够被格式化后，作为数据存取的分割槽为主要分割与逻辑分割。扩展分配无法格式化；
　　● 分割槽的最小单位为磁柱（cylinder）；
　　● 逻辑分割的数量依操作系统而不同，在Linux系统中，IDE硬盘最多有59个逻辑分割（5号到63号），SATA硬盘则有11个逻辑分割（5号到15号）；
　　● 当系统要写入磁碟时，一定会参考磁盘分区表，才能针对某个分割槽进行数据的处理。
　　8内存与外存的比较：
该文章仅供学习参考使用，版权归作者所有。
因本网站内容较多，未能及时联系上的作者，请按本网站显示的方式与我们联系。
【】【】【】【】
上一篇：下一篇：
本文已有(0)篇评论
发表技术资料评论，请使用文明用语
字符数不能超过255
暂且没有评论!
12345678910
12345678910
12345678910
本文为您介绍波峰焊平常使用会碰到的焊接问题，以及对应的焊接解决方法。
　　A、 焊料不足：
[][][][][][][][][][]
IC热门型号
IC现货型号
推荐电子百科dongisland 的BLOG
用户名：dongisland
文章数：10
访问量：348
注册日期：
阅读量：5863
阅读量：12276
阅读量：349206
阅读量：1048303
51CTO推荐博文
StrutsStruts 2的基本流程（Struts2继承了Struts与WebWork的血脉，吸取了两者的精华而成） & &Struts 2框架由3个部分组成：核心控制器FilterDispatcher、业务控制器和用户实现的业务逻辑组件。在这3个部分里， &Struts 2框架提供了核心控制器FilterDispatcher，而用户需要实现业务控制器和业务逻辑组件。核心控制器：FilterDispatcher & &FilterDispatcher是Struts 2框架的核心控制器，该控制器作为一个Filter运行在Web应用中，它负责拦截所有的用户请求，当用户请求到达时，该Filter会过滤用户请求。如果用户请求以action结尾，该请求将被转入Struts 2框架处理。Struts 2框架获得了*.action请求后，将根据*.action请求的前面部分决定调用哪个业务逻辑组件，例如，对于login.action请求，Struts 2调用名为login的Action来处理该请求。 & &Struts 2应用中的Action都被定义在struts.xml文件中，在该文件中定义Action时，定义了该Action的name属性和class属性，其中name属性决定了该Action处理哪个用户请求，而class属性决定了该Action的实现类。Struts 2用于处理用户请求的Action实例，并不是用户实现的业务控制器，而是Action代理――因为用户实现的业务控制器并没有与Servlet API耦合，显然无法处理用户请求。而Struts 2框架提供了系列拦截器，该系列拦截器负责将HttpServletRequest请求中的请求参数解析出来，传入到Action中，并回调Action 的execute方法来处理用户请求。显然，上面的处理过程是典型的AOP（面向切面编程）处理方式。Struts1的工作原理 & &在Struts中，用户的请求一般以*.do作为请求服务名，所有的*.do请求均被指向ActionSevlet， ActionSevlet根据Struts-config.xml中的配置信息，将用户请求封装成一个指定名称的FormBean，并将此 FormBean传至指定名称的ActionBean，由ActionBean完成相应的业务操作，如文件操作，数据库操作等。每一个*.do均有对应的 FormBean名称和ActionBean名称，这些在Struts-config.xml中配置。（这里面有更详细的描述）HibernateHibernate原理：1.读取并解析配置文件2.读取并解析映射信息，创建SessionFactory3.打开Sesssion4.创建事务Transation5.持久化操作6.提交事务7.关闭Session8.关闭SesstionFactory为什么要使用Hibernate？1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。Hibernate是如何延迟加载?1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）2. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并没有存在于内存中，当程序真正对数据的操作时，对象才存在于内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。更详细的Hibernate延迟加载Hibernate的缓存机制1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存2. 二级缓存：a) 应用及缓存b) 分布式缓存条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 关键数据c) 第三方缓存的实现Hibernate缓存的作用 & &Hibernate是一个持久层框架，经常访问物理数据库，为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据Hibernate缓存分类 & &Hibernate缓存包括两大类：Hibernate一级缓存和Hibernate二级缓存Hibernate一级缓存又称为“Session的缓存”，它是内置的，不能被卸载（不能被卸载的意思就是这种缓存不具有可选性，必须有的功能，不可以取消session缓存）。由于Session对象的生命周期通常对应一个数据库事务或者一个应用事务，因此它的缓存是事务范围的缓存。第一级缓存是必需的，不允许而且事实上也无法卸除。在第一级缓存中，持久化类的每个实例都具有唯一的OID。 Hibernate二级缓存又称为“SessionFactory的缓存”，由于SessionFactory对象的生命周期和应用程序的整个过程对应，因此Hibernate二级缓存是进程范围或者集群范围的缓存，有可能出现并发问题，因此需要采用适当的并发访问策略，该策略为被缓存的数据提供了事务隔离级别。第二级缓存是可选的，是一个可配置的插件，在默认情况下，SessionFactory不会启用这个插件。什么样的数据适合存放到第二级缓存中？ 　1 很少被修改的数据 　　2 不是很重要的数据，允许出现偶尔并发的数据 　　3 不会被并发访问的数据 　　4 常量数据 　　不适合存放到第二级缓存的数据？ 　1 经常被修改的数据 　　2 绝对不允许出现并发访问的数据，如财务数据，绝对不允许出现并发 　　3 与其他应用共享的数据Hibernate查找对象如何应用缓存？当Hibernate根据ID访问数据对象的时候，首先从Session一级缓存中查；查不到，如果配置了二级缓存，那么从二级缓存中查；如果都查不到，再查询数据库，把结果按照ID放入到缓存删除、更新、增加数据的时候，同时更新缓存Hibernate管理缓存实例 & &无论何时，我们在管理Hibernate缓存（Managing the caches）时，当你给save()、update()或saveOrUpdate()方法传递一个对象时，或使用load()、 get()、list()、iterate() 或scroll()方法获得一个对象时, 该对象都将被加入到Session的内部缓存中。
& &当随后flush()方法被调用时，对象的状态会和数据库取得同步。 如果你不希望此同步操作发生，或者你正处理大量对象、需要对有效管理内存时，你可以调用evict() 方法，从一级缓存中去掉这些对象及其集合。 Hibernate的缓存范围 Hibernate的一级缓存和二级缓存都位于均位于持久层,且均用于存放数据库数据的副本,最大的区别就是缓存的范围各不一样. 缓存的范围分为3类: 1.事务范围
& &事务范围的缓存只能被当前事务访问,每个事务都有各自的缓存,缓存内的数据通常采用相互关联的对象形式.缓存的生命周期依赖于事务的生命周期,只有当事务结束时,缓存的生命周期才会结束.事务范围的缓存使用内存作为存储介质,一级缓存就属于事务范围.2.应用范围
& &应用程序的缓存可以被应用范围内的所有事务共享访问.缓存的生命周期依赖于应用的生命周期,只有当应用结束时,缓存的生命周期才会结束.应用范围的缓存可以使用内存或硬盘作为存储介质,二级缓存就属于应用范围. 3.集群范围
& &在集群环境中,缓存被一个机器或多个机器的进程共享,缓存中的数据被复制到集群环境中的每个进程节点,进程间通过远程通信来保证缓存中的数据的一致,缓存中的数据通常采用对象的松散数据形式. Hibernate的缓存管理 一级缓存的管理: evit(Object obj) &将指定的持久化对象从一级缓存中清除,释放对象所占用的内存资源,指定对象从持久化状态变为脱管状态,从而成为游离对象. clear() &将一级缓存中的所有持久化对象清除,释放其占用的内存资源 contains(Object obj) 判断指定的对象是否存在于一级缓存中. flush() 刷新一级缓存区的内容,使之与数据库数据保持同步. 二级缓存的管理: evict(Class arg0, Serializable arg1) &将某个类的指定ID的持久化对象从二级缓存中清除,释放对象所占用的资源. sessionFactory.evict(Customer.class, new Integer(1));evict(Class arg0) &将指定类的所有持久化对象从二级缓存中清除,释放其占用的内存资源. sessionFactory.evict(Customer.class);evictCollection(String arg0) &将指定类的所有持久化对象的指定集合从二级缓存中清除,释放其占用的内存资源. sessionFactory.evictCollection("Customer.orders");Hibernate的二级缓存功能是靠配置二级缓存插件来实现的,Hibernate为了集成这些插件,Hibernate提供了org.hibernate.cache.CacheProvider接口,它充当缓存插件与Hibernate之间的适配器 . 常用的二级缓存插件 EHCache &org.hibernate.cache.EhCacheProvider OSCache &org.hibernate.cache.OSCacheProvider SwarmCahe &org.hibernate.cache.SwarmCacheProvider JBossCache &org.hibernate.cache.TreeCacheProvider 简单介绍一下EHCache的配置 hibernate.cfg.xml&hibernate-configuration&
&session-factory&
&!-- 设置二级缓存插件EHCache的Provider类--&
&property name="hibernate.cache.provider_class"&
org.hibernate.cache.EhCacheProvider
&/property&
&!-- 启动"查询缓存" --&
&property name="hibernate.cache.use_query_cache"&
&/property&
&/session-factory&
&/hibernate-configuration&ehcache.xml &ehcache&
&!-- maxElementsInMemory为缓存对象的最大数目, eternal设置是否永远不过期,timeToIdleSeconds对象处于空闲状态的最多秒数,timeToLiveSeconds对象处于缓存状态的最多秒数 --&
&diskStore path="java.io.tmpdir"/&
&defaultCache maxElementsInMemory="10000" eternal="false"
timeToIdleSeconds="300" timeToLiveSeconds="600" overflowToDisk="true"/&
&/ehcache&****.hbm.xml &?xml version="1.0" encoding='UTF-8'?&
&!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" &
&hibernate-mapping&
&!-- 设置该持久化类的二级缓存并发访问策略 read-only read-write nonstrict-read-write transactional--&
&cache usage="read-write"/&
&/hibernate-mapping&如何优化Hibernate？ & &Hibernate是对JDBC的轻量级封装，因此在很多情况下Hibernate的性能比直接使用JDBC存取数据库要低。然而，通过正确的方法和策略，在使用Hibernate的时候还是可以非常接近直接使用JDBC时的效率的，并且，在有些情况下还有可能高于使用JDBC时的执行效率。在进行Hibernate性能优化时，需要从以下几个方面进行考虑：● 数据库设计调整。● HQL优化。● API的正确使用（如根据不同的业务类型选用不同的集合及查询API）。● 主配置参数（日志、查询缓存、fetch_size、batch_size等）。● 映射文件优化（ID生成策略、二级缓存、延迟加载、关联优化）。● 一级缓存的管理。● 针对二级缓存，还有许多特有的策略。● 事务控制策略。 & &数据的查询性能往往是影响一个应用系统性能的主要因素。对查询性能的影响会涉及到系统软件开发的各个阶段，例如，良好的设计、正确的查询方法、适当的缓存都有利于系统性能的提升。 & &系统性能的提升设计到系统中的各个方面，是一个相互平衡的过程，需要在应用的各个阶段都要考虑。并且在开发、运行的过程中要不断地调整和优化才能逐步提升系统的性能。Spring用于整合，好处是解耦。 解耦，可以降低组件不组件之间的关联，改善程序结构，便于系统的维护和扩展。Spring工作原理
& &内部最核心的就是IOC了即动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射机制，反射其实就是在运行时动态的去创建、调用对象。Spring就是在运行时，利用Spring的配置文件XML信息来动态的创建对象，和调用对象里的方法。 & Spring还有一个核心就是AOP面向切面编程，可以为某一类对象进行监督和控制（也就是在调用这类对象的具体方法的前后去调用你指定的模块）从而达到对一个模块扩充的功能。这些都是通过配置类达到的。Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，而是通过配置类说明管理的（Spring根据这些配置内部通过反射去动态的组装对象） Spring是一个容器，凡是在容器里的对象才会有Spring所提供的这些服务和功能。 Spring 里用的最经典的一个设计模式就是：模板方法模式。-----------------------------------又是题外话下面简单介绍一下spring中涉及到的设计模式---------------------------------1.简单工厂 又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。 简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。 spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。 2.工厂方法（Factory Method） 定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。 spring中的FactoryBean就是典型的工厂方法模式。如下图： 3.单例（Singleton） 保证一个类仅有一个实例，并提供一个访问它的全局访问点。 spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是因为spring管理的是是任意的java对象。 4.适配器（Adapter） 将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 spring中在对于aop的处理中有Adapter模式的例子，见如下图： 5.包装器（Decorator） 动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。 spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。 6.代理（Proxy） 为其他对象提供一种代理以控制对这个对象的访问。 从结构上来看和Decorator模式类似，但Proxy是控制，更像是一种对功能的限制，而Decorator是增加职责。 spring的Proxy模式在aop中有体现，比如JdkDynamicAopProxy和Cglib2AopProxy。7.观察者（Observer） 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 spring中Observer模式常用的地方是listener的实现。如ApplicationListener。 8.模板方法（Template Method） 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 Template Method模式一般是需要继承的。这里想要探讨另一种对Template Method的理解。spring中的JdbcTemplate，在用这个类时并不想去继承这个类，因为这个类的方法太多，但是我们还是想用到JdbcTemplate已有的稳定的、公用的数据库连接，那么我们怎么办呢？我们可以把变化的东西抽出来作为一个参数传入JdbcTemplate的方法中。但是变化的东西是一段代码，而且这段代码会用到JdbcTemplate中的变量。怎么办？那我们就用回调对象吧。在这个回调对象中定义一个操纵JdbcTemplate中变量的方法，我们去实现这个方法，就把变化的东西集中到这里了。然后我们再传入这个回调对象到JdbcTemplate，从而完成了调用。这可能是Template Method不需要继承的另一种实现方式吧。 Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：☆ 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。☆ Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。☆ Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。☆ Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。☆ Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。☆ Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。☆ Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、测试环境之间重用。IOC和AOPIOCInversion of Control 控制反转，也叫（Dependency Injection）依赖注入，就是DAO接口的实现不再是业务逻辑层调用工厂类去获取，而是通过容器（spring）来自动的为我们的业务层设置DAO的实现类，这样整个过程就反过来，以前是我们业务层主动去获取DAO，而现在是DAO主动被设置到业务逻辑层中来了，这也就是反转控制的由来。通过IOC，我们就可以在不修改任何代码的情况下，无缝的实现数据库的换库迁移 如例子（比如有类A和类B，我们之前的做法是在A中调用B，那么控制权就在A中，这样做的耦合度较高，如果修改了B，A也要做相应修改，引入Spring框架后，控制权由spring容器来负责。当A想使用B时，需要由Spirng容器通过配置文件行注入。这种思想就是IoC）依赖注入的形式主要有三种，我分别将它们叫做构造子注入（Constructor Injection）、设值方法注入（Setter Injection）和接口注入（Interface Injection）。IOC原理publicclassUserService{
//private UserDao userDao = new UserDaoImpl();
//让业务层与数据访问层耦合在一起,不利用以后模块的替换.
privateUserDao userDao_IoC =
publicvoidsetUserDao(UserDao userDao){
this.userDao_IoC = userDao
publicvoidsave(User user){
userDao.save(user);
//原理：反射
publicvoidObjectgetInstance(String className) throwsException {
Object obj = Class.forName(className).newInstance();
Method[] methods = obj.getClass().getMethods();
for(Method method : methods) {
if(method.getName().intern() == "setUserDao") {
method.invoke(obj, "换成实现接口类的名称!");
}AOPAspect Oriented Programming 面向切面编程，它帮助我们生成动态的代理类，织入新的业务逻辑，如事务，日志等等可以通过预编译方式和运行期动态代理实现在不修改源代码的前提下给程序劢态统一添加功能的一种技术。AOP原理package com.s2sh.
public interface IHello {
public void sayHello(String name);
public void sayGoogBye(String name);
package com.s2sh.
public class Hello implements IHello {
public void sayGoogBye(String name) {
// TODO Auto-generated method stub
System.out.println(name+" GoodBye!");
public void sayHello(String name) {
// TODO Auto-generated method stub
System.out.println("Hello " + name);
package com.s2sh.
public class Logger {
public static void before() {
System.out.println("开始了");
public static void after() {
System.out.println("结束了");
package com.s2sh.
import java.lang.reflect.InvocationH
import java.lang.reflect.M
import java.lang.reflect.P
public class DynaProxyHello implements InvocationHandler {
private O//被代理的对象
public DynaProxyHello(Object delegate) {
this.delegate =
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
Object result =
// 执行原来的方法之前记录日志
Logger.before();
// JVM通过这条语句执行原来的方法(反射机制)
result = method.invoke(this.delegate, args);
// 执行原来的方法之后记录日志
Logger.after();
} catch (Exception e) {
e.printStackTrace();
// 返回方法返回值给调用者
package com.s2sh.
import java.lang.reflect.P
public class Test {
public static void main(String[] args) {
// ①目标业务类
IHello target = new Hello();
// ② 将目标业务类和横切代码编织到一起
DynaProxyHello handler = new DynaProxyHello(target);
// 创建代理类
IHello proxy = (IHello) Proxy.newProxyInstance(
target.getClass().getClassLoader(), //返回目标类的类装载器，保持两个类的类装载器一样
target.getClass().getInterfaces(), //返回目标类实现的接口，保证组合而成的代理类也实现这些接口
handler//指派谁去处理方法的对象
// ④ 操作代理实例
proxy.sayHello("张三");
proxy.sayGoogBye("李四");
}本文出自 “” 博客，请务必保留此出处
了这篇文章
类别：未分类┆阅读(0)┆评论(0)}