Redis构建高可用架构实践之路Alfresco案例-redis的akf (redis构建全局变量java)

Redis构建高可用架构实践之路：Alfresco案例

Redis是一款高性能的内存缓存数据库，它具备高效、稳定、可扩展、灵活等诸多优点。在高并发场景下，Redis可以大大提升数据访问的效率，实现高可用架构的构建。本文将以Alfresco案例为例，介绍Redis如何构建高可用架构。

一、Redis的高可用架构

Redis提供了主从复制和哨兵容错机制来保证高可用性。主从复制是指将Redis的一份数据向其他Redis节点同步，实现性能的水平扩展和数据备份。哨兵容错机制则是指在主 服务器 宕机时，自动将从服务器中的一个节点升级为主服务器，保障服务的可用性。

Redis的主从复制和哨兵容错机制图如下所示：

二、Alfresco案例

Alfresco是一款优秀的内容管理系统，广泛应用于企业级文档管理、协同办公等场景。在Alfresco的架构中，使用了Redis构建高可用架构，提升了系统稳定性和性能。

Alfresco项目中使用的Redis版本为3.2.9，配置文件如下所示：

其中重要的配置参数有：

bind：绑定的IP地址，指定Redis服务绑定的IP地址。

port：Redis服务运行的端口号。

pidfile：Redis服务的进程ID，用于监控服务状态。

logfile：Redis运行日志文件。

dbfilename：Redis持久化文件名。

dir：Redis数据存储目录。

在实际开发中，可以根据实际情况修改Redis的配置参数，满足不同业务场景需求。

三、Redis的使用方法

在Alfresco项目中，Redis主要用于缓存对象，提供快速的数据读取和操作。在程序中使用Redis库，需要按照以下步骤进行：

1、安装Redis库

在Linux系统上使用以下命令安装Redis：

sudo apt-get install redis-server

2、连接Redis服务

在程序中连接Redis服务，可以使用以下代码：

private Jedis jedis;

public void connectRedis() {

jedis = new Jedis(redis_host, redis_port);

其中，指定Redis服务的IP地址和端口号。

3、设置缓存

在程序中设置Redis缓存，可以使用以下代码：

public void setCache(String key, String value, int seconds) {

jedis.setex(key, seconds, value);

其中，key表示缓存的键，value表示缓存的值，seconds表示缓存的时间（单位：秒）。

4、读取缓存

在程序中读取Redis缓存，可以使用以下代码：

public String getCache(String key) {

return jedis.get(key);

其中，key表示缓存的键。

通过以上步骤，程序就可以使用Redis进行数据的缓存和读写操作。

四、结语

本文介绍了Redis的高可用架构和在Alfresco项目中的应用，通过Redis的主从复制和哨兵容错机制，实现了系统的高可用性。在实际开发中，可以根据业务需求灵活配置Redis的参数，提升系统性能和稳定性。

香港服务器首选树叶云，2H2G首月10元开通。树叶云（www.IDC.Net）提供简单好用，价格厚道的香港/美国云服务器和独立服务器。IDC+ISP+ICP资质。ARIN和APNIC会员。成熟技术团队15年行业经验。

要当Java工程师，需要掌握什么技能？

Java工程师需要掌握的技能还是比较多的。 技能傍身才能较好的应对工作，而且不同的Java开发岗位对于面试者的需求也是不一样的。

相关技能可以参考如下：

第一阶段，Java核心基础：

1.深入理解Java面向对象思想

2.掌握开发中常用基础API

3.熟练使用集合框架、IO流、异常

4.能够基于JDK8开发

第二阶段，数据库关键技术

1.掌握最流行关系型数据MySQL常见操作

2.熟练增删改查数据处理

3.掌握Java JDBC、连接池操作

第三阶段，Web网页技术

1.掌握基本的JavaWeb基础知识JSP/Servlet/jQuery等

2.具备基本的B/S结构软件开发能力

3.可以动手开发一个B/S架构的Web项目

第四阶段，开发必备框架&技术

1.掌握SSM框架技术

2.掌握使用Maven进行模块的开发

3.熟悉基本的Linux命令以及Linux服务器的使用

4.掌握高级缓存技术Redis的原理，并熟练使用

第五阶段，互联网高级技术

分布式管理系统、Keepalived+Nginx主备、微服务架构技术、消息中间件技术、MySQL调优、高并发技术、性能优化、内存和GC等

第六阶段，前沿技术&大型企业级项目

edis的原理，并熟练使用

Windows Server 2008 R2 的VOL版与零售版的有没有区别

WindowsServer2008R2基础版（Foundation）：一个廉价的入门级版本，支持单路处理器，提供了中小企业应用最多的文件与打印共享、远程访问、目录服务等，并且在安全性上没有缩水。 适合作为中小企业文件打印服务器、文件共享服务器、用于网络基础架构管理的域控制器和终端服务器等等。 不过基础版并不单独发售，是随同OEM的单路服务器一同提供给用户。 标准版（Standard）：提供了基础的Web、虚拟化、安全性、可靠性和生产特性，并平衡了成本。 最高支持4颗x64处理器、32GB内存、最大支持250个网络访问连接、集成Hyper-v、IIS7.5、远程桌面服务、具备ServerCore模式，支持Powershell2.0。 企业版（Enterprise）：提供了强大的可靠性和可扩展性，相对标准版功能更加全面，如最大支持2TB内存，最大支持8颗x64处理器，也不再有连接数的限制，具有更加丰富的管理功能和特性如ADRMS、DirectAccess等，此外具有丰富的容错选项，支持16节点的容错群集，具有同步内存容错功能等等，是一个强大的企业管理平台。 数据中心版（Datacenter）：Win2008R2中的最高级版本，提供了高扩展性、可靠性和可用性，适合大规模的虚拟化应用，以及大型的关键应用，如ERP、数据库等商业应用。 和企业版相比，数据中心版更适合大规模的虚拟化应用，消除了虚拟化使用限制，具有快速迁移等特性，具有更佳的可用性。 在扩展性上更强，最大支持64颗64位处理器、2TB内存，与企业版相比，同样具有丰富的容错特性。 Web版：一个功能单一的版本，价格比较低廉，主要用于构建Web服务器，集成IIS7.5、、，让用户可以快速的部署网页、网络站点、Web应用和服务。 Web版本最大支持4颗x64服务器和最高32GB内存。 WindowsWebServer2008R2　安腾版（Itanium-BasedSystems）：支持64颗IA64处理器、2TB内存，支持热替换内存和热替换处理器功能、支持8节点容错群集、具有同步内存容错功能，并消除虚拟机数量限制，是一个高扩展、高可用的企业级平台。 注意：1、由于WindowsServer2008R2完全架构于64位平台，故而处理器只支持x64架构处理器，这一点和WindowsServer2008是不同的，在安装的时候用cpu-z查看指令集是否包含EM64T(INTEL)或者X86_64(AMD)指令。 2、安腾版WindowsServer2008R2需要IntelItanium2处理器。

c++对代码复用是通过什么途径支持的？

对接口编程对接口编程是面向对象设计（OOD）的第一个基本原则。 它的含义是：使用接口和同类型的组件通讯，即，对于所有完成相同功能的组件，应该抽象出一个接口，它们都实现该接口。 具体到JAVA中，可以是接口（interface），或者是抽象类（abstract class），所有完成相同功能的组件都实现该接口，或者从该抽象类继承。 我们的客户代码只应该和该接口通讯，这样，当我们需要用其它组件完成任务时，只需要替换该接口的实现，而我们代码的其它部分不需要改变！当现有的组件不能满足要求时，我们可以创建新的组件，实现该接口，或者，直接对现有的组件进行扩展，由子类去完成扩展的功能。 优先使用对象组合，而不是类继承优先使用对象组合，而不是类继承是面向对象设计的第二个原则。 并不是说继承不重要，而是因为每个学习OOP的人都知道OO的基本特性之一就是继承，以至于继承已经被滥用了，而对象组合技术往往被忽视了。 下面分析继承和组合的优缺点：类继承允许你根据其他类的实现来定义一个类的实现。 这种通过生成子类的复用通常被称为白箱复用(white-box reuse)。 术语白箱是相对可视性而言：在继承方式中，父类的内部细节对子类可见。 对象组合是类继承之外的另一种复用选择。 新的更复杂的功能可以通过组合对象来获得。 对象组合要求对象具有良好定义的接口。 这种复用风格被称为黑箱复用(black-box reuse)，因为被组合的对象的内部细节是不可见的。 对象只以黑箱的形式出现。 继承和组合各有优缺点。 类继承是在编译时刻静态定义的，且可直接使用，类继承可以较方便地改变父类的实现。 但是类继承也有一些不足之处。 首先，因为继承在编译时刻就定义了，所以无法在运行时刻改变从父类继承的实现。 更糟的是，父类通常至少定义了子类的部分行为，父类的任何改变都可能影响子类的行为。 如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更适合的类替换。 这种依赖关系限制了灵活性并最终限制了复用性。 对象组合是通过获得对其他对象的引用而在运行时刻动态定义的。 由于组合要求对象具有良好定义的接口，而且，对象只能通过接口访问，所以我们并不破坏封装性；只要类型一致，运行时刻还可以用一个对象来替代另一个对象；更进一步，因为对象的实现是基于接口写的，所以实现上存在较少的依赖关系。 优先使用对象组合有助于你保持每个类被封装，并且只集中完成单个任务。 这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物（这正是滥用继承的后果）。 另一方面，基于对象组合的设计会有更多的对象(但只有较少的类)，且系统的行为将依赖于对象间的关系而不是被定义在某个类中。 注意：理想情况下，我们不用为获得复用而去创建新的组件，只需要使用对象组合技术，通过组装已有的组件就能获得需要的功能。 但是事实很少如此，因为可用的组件集合并不丰富。 使用继承的复用使得创建新的组件要比组装已有的组件来得容易。 这样，继承和对象组合常一起使用。 然而，正如前面所说，千万不要滥用继承而忽视了对象组合技术。 相关的设计模式有： Bridge、Composite、Decorator、Observer、Strategy等。 下面的例子演示了这个规则，它的前提是：我们对同一个数据结构，需要以任意的格式输出。 第一个例子，我们使用基于继承的框架，可以看到，它很难维护和扩展。 abstract class AbstractExampleDocument{// skip some code void output(Example structure){if( null != structure ){( structure );}}protected void format(Example structure);}第二个例子，我们使用基于对象组合技术的框架，每个对象的任务都清楚的分离开来，我们可以替换、扩展格式类，而不用考虑其它的任何事情。 class DefaultExampleDocument {// skip some code void output(Example structure) {ExampleFormatter formatter = (ExampleFormatter) ();if( null != structure ) {(structure);}}}这里，用到了类似于抽象工厂的组件创建模式，它将组件的创建过程交给manager来完成；ExampleFormatter是所有格式的抽象父类； 将可变的部分和不可变的部分分离 将可变的部分和不可变的部分分离是面向对象设计的第三个原则。 如果使用继承的复用技术，我们可以在抽象基类中定义好不可变的部分，而由其子类去具体实现可变的部分，不可变的部分不需要重复定义，而且便于维护。 如果使用对象组合的复用技术，我们可以定义好不可变的部分，而可变的部分可以由不同的组件实现，根据需要，在运行时动态配置。 这样，我们就有更多的时间关注可变的部分。 对于对象组合技术而言，每个组件只完成相对较小的功能，相互之间耦合比较松散，复用率较高，通过组合，就能获得新的功能。 减少方法的长度通常，我们的方法应该只有尽量少的几行，太长的方法会难以理解，而且，如果方法太长，则应该重新设计。 对此，可以总结为以下原则：☆ 三十秒原则：如果另一个程序员无法在三十秒之内了解你的函数做了什么（What），如何做(How)以及为什么要这样做(Why)，那就说明你的代码是难以维护的，必须得到提高； ☆ 一屏原则：如果一个函数的代码长度超过一个屏幕，那么或许这个函数太长了，应该拆分成更小的子函数； ☆ 一行代码尽量简短，并且保证一行代码只做一件事：那种看似技巧性的冗长代码只会增加代码维护的难度。 消除case / if语句要尽量避免在代码中出现判断语句，来测试一个对象是否某个特定类的实例。 通常，如果你需要这么做，那么，重新设计可能会有所帮助。 我在工作中遇到这样的一个问题：我们在使用JAVA做XML解析时，对每个标签映射了一个JAVA类，采用SAX（简单的XML接口API：Simple API for XML）模型。 结果，代码中反复出现了大量的判断语句，来测试当前的标签类型。 为此，我们重新设计了DTD（文档类型定义：Document Type Definition），为每个标签增加了一个固定的属性：classname，而且重新设计了每个标签映射的JAVA类的接口，统一了每个对象的操作：addElement(Element aElement); //增加子元素addAttribute(String attName, String attValue); //增加属性； 则彻底消除了所有的测试当前的标签类型的判断语句。 每个对象通过 ((classname))(); 动态创建， 减少参数个数有大量参数需要传递的方法，通常很难阅读。 我们可以将所有参数封装到一个对象中来完成对象的传递，这也有利于错误跟踪。 许多程序员因为，太多层的对象包装对系统效率有影响。 是的，但是，和它带来的好处相比，我们宁愿做包装。 毕竟，封装也是OO的基本特性之一，而且，每个对象完成尽量少（而且简单）的功能，也是OO的一个基本原则。 类层次的最高层应该是抽象类在许多情况下，提供一个抽象基类有利做特性化扩展。 由于在抽象基类中，大部分的功能和行为已经定义好，使我们更容易理解接口设计者的意图是什么。 由于JAVA不允许多继承，从一个抽象基类继承，就无法再从其它基类继承了。 所以，提供一个抽象接口(interface)是个好主意，一个类可以实现多个接口，从而模拟实现了多继承，为类的设计提供了更大的灵活性。 尽量减少对变量的直接访问对数据的封装原则应该规范化，不要把一个类的属性暴露给其它类，而是应该通过访问方法去保护他们，这有利于避免产生波纹效应。 如果某个属性的名字改变，你只需要修改它的访问方法，而不是修改所有相关的代码。 子类应该特性化，完成特殊功能如果一个子类只是使一个组件变成组件管理器，而不是实现接口功能，或者，重载某个功能，那么，就应该使用一个外部的容器类，而不是创建一个子类。 建议：类层次结构图，不要太深；例如：下面的接口定义了组件的功能：发送消息；类Transceiver实现了该接口；而其子类Pool只是管理多个Transceiver对象，而没有提供自己的接口实现。 建议使用组合方式，而不是继承！public interface ITransceiver{public abstract send(String msg);}public class Transceiver implements ITransceiver {public send(String msg){(msg);}}//使用继承方式的实现public class Pool extends Transceiver{private Listpool = new Vector();public void add(Transceiver aTransceiver){(aTransceiver);}public Transceiver get(int index){(index);}}//使用组合方式的实现public class Pool {private Listpool = new Vector();public void add(Transceiver aTransceiver){(aTransceiver);}public Transceiver get(int index){(index);}}拆分过大的类如果一个类有太多的方法（超过50个），那么它可能要做的工作太多，我们应该试着将它的功能拆分到不同的类中，类似于规则四。 作用截然不同的对象应该拆分在构建的过程中，你有时会遇到这样的问题：对同样的数据，有不同的视图。 某些属性描述的是数据结构怎样生成，而某些属性描述的是数据结构本身。 最好将这两个视图拆分到不同的类中，从类名上就可以区分出不同视图的作用。 类的域、方法也应该有同样的考虑！尽量减少对参数的隐含传递两个方法处理类内部同一个数据（域），并不意味着它们就是对该数据（域）做处理。 许多时候，该数据（域）应该作为方法的参输入数，而不是直接存取，在工具类的设计中尤其应该注意。 例如：public class Test{private Listpool = new Vector();public void testAdd(String str){(str);}public Object testGet(int index){(index);}}两个方法都对List对象pool做了操作，但是，实际上，我们可能只是想对List接口的不同实现Vector、ArrayList等做存取测试。 所以，代码应该这样写：public class Test{private Listpool = new Vector();public void testAdd(Listpool, String str){(str);}public Object testGet(Listpool, int index){(index);}}