作者归档:Rick

Java使用缓存memcached-HelloWorld

maven:

 <dependency>
	<groupId>com.whalin</groupId>
	<artifactId>Memcached-Java-Client</artifactId>
	<version>3.0.0</version>
</dependency>

CacheHelper.java

import com.whalin.MemCached.MemCachedClient;
import com.whalin.MemCached.SockIOPool;

public class CacheHelper {  
    
    /* 单例模式 */  
    protected static MemCachedClient mcc = new MemCachedClient();  
      
    private CacheHelper() {  
    }  
      
    /* 配置服务器组 */  
    static {  
          
        /* 定义IP地址和端口 */  
        String[] servers = {"121.42.151.190:11211"};  
          
        /* 设置缓存大小 */  
        Integer[] weights = { 2 };  
          
        /* 拿到一个连接池的实例 */  
        SockIOPool pool = SockIOPool.getInstance();  
          
        /* 注入服务器组信息 */  
        pool.setServers(servers);  
        pool.setWeights(weights);  
          
        /* 配置缓冲池的一些基础信息 */  
        pool.setInitConn(5);  
        pool.setMinConn(5);  
        pool.setMaxConn(250);  
        pool.setMaxIdle(1000 * 60 * 60 * 6);  
          
        /* 设置线程休眠时间 */  
        pool.setMaintSleep(30);  
          
        /* 设置关于TCP连接 */  
        pool.setNagle(false);// 禁用nagle算法  
        pool.setSocketConnectTO(0);  
        pool.setSocketTO(3000);// 3秒超时  
          
        /* 初始化 */  
        pool.initialize();  
          
        /* 设置缓存压缩 */  
//        mcc.setCompressEnable(true);  
//        mcc.setCompressThreshold(64 * 1024);  
          
    }  
      
    public static boolean set(String arg0, Object arg1) {  
        return mcc.set(arg0, arg1);  
    }  
      
    public static Object get(String arg0) {  
        return mcc.get(arg0);  
    }  
      
    /* 测试 */  
    public static void main(String[] args) {  
        CacheHelper.set("gogo", "gogogogo");  
        System.out.println(CacheHelper.get("gogo"));// gogogogo  
        System.out.println(CacheHelper.get("gogog"));// null  
        /* 如果出现都为null,检查地址和端口。端口可以到Memcached同目录配置文件看。
          相关文章链接http://xhope.top/?p=413 */  
    }  
      
} 

输出:

Centos下memcached安装

memcached下载地址:http://memcached.org/downloads

(无需下载可以在线安装)

安装分为两部分:

安装官方教程

安装libevent

   由于linux系统可能默认已经安装libevent,

   执行命令:rpm -qa|grep libevent查看系统是否带有该安装软件

   如果有执行命令:rpm -e libevent-1.1a-3.2.1 –nodeps(由于系统自带的版本旧,忽略依赖删除)


 如果没有安装

#yum install libevent-devel

安装memcached

#wget http://memcached.org/latest
#tar -zxvf memcached-1.4.22.tar.gz
#cd memcached-1.4.22
#./configure && make && make test && sudo make install

至此memcached安装成功

启动/停止memcached

memcached -d -m 256 -u root -p 11211 -c 1024 –P /tmp/memcached.pid

端口是11211

检查端口:

# netstat -atunlp

停止memcached进程:

#kill 12032

相关文档:

http://xhope.top/wp-content/uploads/2015/02/memcached-黑夜路人.pdf

网站缓存技术

  

文章转自:http://dcross.iteye.com/blog/721468

  网站技术高速发展的今天,缓存技术已经成为大型网站的一个关键技术,缓存设计好坏直接关系的一个网站访问的速度,以及购置服务器的数量,甚至影响到用户的体验。

网站缓存按照存放的地点不同,可以分为客户端缓存、服务端缓存。

客户端缓存

客户端缓存又可分为:浏览器缓存、网关或代理服务器缓存
网关或代理服务器缓存是将网页缓存中网关服务器上,多用户访问同一个页面时,将直接从网关服务器把页面传送给用户。
浏览器缓存是最靠近用户的缓存,如果启用缓存,用户在访问同一个页面时,将不再从服务器下载页面,而是从本机的缓存目录中读取页面,然后再浏览器中展现这个页面。
浏览器缓存的控制,可以设置meta标签,可以设置数字,也可以设置时间,如下:
<Meta http-equiv=”Expires” Content=”3600″>
<Meta http-equiv=”Expires” Content=”Wed, 26 Feb 1997 08:21:57 GMT”>
HTTP头信息如下:
HTTP/1.1 200 OK
Date: Fri, 30 Oct 1998 13:19:41 GMT
Server: Apache/1.3.3 (Unix)
Cache-Control: max-age=3600, must-revalidate
Expires: Fri, 30 Oct 1998 14:19:41 GMT
Last-Modified: Mon, 29 Jun 1998 02:28:12 GMT
不过现在的网站为了保证用户访问到最新的内容,一般很少采用浏览器缓存,取而代之的是更加灵活的服务器缓存。

服务端缓存

服务端缓存分为:页面缓存、数据缓存、数据库缓存

1、页面缓存

页面缓存是将动态页面直接生成静态的页面放在服务器端,用户调取相同页面时,静态页面将直接下载到客户端,不再需要通过程序的运行和数据库的访问,大大节约了服务器的负载。
早期的网站很多使用发布系统来完成这个功能,在后台发布时将数据和页面模板整合成静态页面,存放在硬盘中。但这样的缺陷很明显,一是后台的程序的编写很复杂,二是缓存的控制只能通过人为的方式来控制,这对一些更新十分频繁的网站就是一个噩梦,网站可能在不停的做缓存的删除和重建。当然后来出现了一些自动更新这些缓存的框架,比如PHP的SMARTY模板技术,可以定义缓存过期的时间,自动去更新这些缓存。这对一些信息发布类网站已经确实适用了。
除了整个页面的缓存技术,还有一种技术叫做“网页片段缓存技术”,将页面的部分而不是全部进行缓存。代表作有ESI cache。

2、数据缓存

但是当WEB2.0兴起的今天,信息的发布已经不再是管理员统一发布的了,而是所有的用户都在发布信息,用户发布完信息后当然是想看到这些信息,而不是等到缓存时间到刷新后才看到这些数据,于是数据缓存的相关技术也就应运而生了。
比较有名的数据缓存框架有ehcache和 memcached。
ehcache有很多缓存的分支(包括页面缓存的模块),但最核心的模块还是它的数据缓存部分,比如,当ehcache和hibernate进行整合时,能将查询出的对象集合放入内存中,下次如果再查询这个查询,将直接从内存中返回这个数据集合,不需要再进行数据库的查询,同时,你可以配置缓存的刷新模式,有read-only,nonstrict-read-write,read-write 几种模式,其中read-only表示缓存是不刷新的(要刷新就只有重启了),nonstrict-read-write表示刷新是不及时的,你可以设置超时的时间去刷新,read-write表示在数据发生变化时缓存都会发生刷新,具体怎么配置可能就要根据具体业务了。
Memcached大致的原理也和ehcache 相同,将数据采用键值的形式存放在内存中,使用时可以将查询的md5作为键,查询的结果作为值。相对ehcache而言,memcached是一个工具,ehcache是一个框架,memcached更加底层更加灵活,当然你也要写相应的代码去使用它。
这是一张网上的memcached图,说明了memcached在系统中的位置。


近几年兴起的NOSQL技术,虽然现在归于数据库的一种,但其本质也是缓存技术和数据库技术的一种融合产物。
目前缓存的做法分为两种模式:
内存缓存:缓存数据存放在服务器的内存空间中。
优点:速度快 缺点:资源有限
文件缓存:缓存数据存放在服务器的硬盘空间中。
优点:容量大 缺点:速度偏慢,尤其在缓存数量巨大时

数据库缓存

数据库的缓存一般由数据库提供,比如ORACLE,可以对表建立高速缓存,提高对经常访问的数据的访问速度。

总结

究竟怎样去使用缓存,使用哪一层次的缓存,是由网站本身的具体业务来决定的。缓存技术的一个原则是:让数据更靠近用户。缓存技术是一门博大精深的艺术,我也是只知些皮毛。

JDBC SQL占位符问题

之前一直以为JDBC占位符一直是?,今天发现在Oracle中可以用:abc来表示

如下代码:

 

public class ExcelClient {
 
    /**
     * @param args
     */
    public static final String DBDRIVER = "oracle.jdbc.driver.OracleDriver";
    //连接地址是由各个数据库生产商单独提供的,所以需要单独记住
    public static final String DBURL = "jdbc:oracle:thin:@172.18.50.139:1521:movitechOcl";
    //连接数据库的用户名
    public static final String DBUSER = "space_sm";
    //连接数据库的密码
    public static final String DBPASS = "space_sm";
 	
	public static void main(String[] args) throws Exception {
        Connection con = null; //表示数据库的连接对象
        PreparedStatement pstmt = null; //表示数据库更新操作

        String sql = "SELECT * from sm_scenario t where t.id = :id"; //正确

        Class.forName(DBDRIVER); //1、使用CLASS 类加载驱动程序


        con = DriverManager.getConnection(DBURL, DBUSER, DBPASS); //2、连接数据库
        pstmt = con.prepareStatement(sql); //使用预处理的方式创建对象
        pstmt.setString(1,"1419328510900");

        ResultSet rs = pstmt.executeQuery();
        if(rs.next()) {
            System.out.println(rs.getString(1));

        }

        pstmt.close();
        con.close(); // 4、关闭数据库
    }
}

结论不同数据的驱动不一样,占位符的定义也肯不相同。

1. 在Oracle中占位符可以是?或者:abc

 

2. 在MySQL中站位符只能是?

spring集成quartz入门配置

    Quartz是一个完全由java编写的开源作业调度框架。不要让作业调度这个术语吓着你。尽管Quartz框架整合了许多额外功能, 但就其简易形式看,你会发现它易用得简直让人受不了!。简单地创建一个实现org.quartz.Job接口的java类。Job接口包含唯一的方法:
public void execute(JobExecutionContext context)
throws JobExecutionException;
在你的Job接口实现类里面,添加一些逻辑到execute()方法。一旦你配置好Job实现类并设定好调度时间表,Quartz将密切注意剩余时间。当调度程序确定该是通知你的作业的时候,Quartz框架将调用你Job实现类(作业类)上的execute()方法并允许做它该做的事情。无需报告任何东西给调度器或调用任何特定的东西。仅仅执行任务和结束任务即可。如果配置你的作业在随后再次被调用,Quartz框架将在恰当的时间再次调用它。

maven

 <dependency>
	<groupId>org.quartz-scheduler</groupId>
	<artifactId>quartz</artifactId>
	<version>2.1.7</version>
</dependency> 

spring-quartz.xml

<bean name="job1"  
        class="org.springframework.scheduling.quartz.JobDetailFactoryBean">  
        <property name="jobClass" value="com.movit.test.BusinessJob" />  
        <property name="durability" value="true"></property> 
    </bean>  
    
  	 <!-- 触发器 -->  
    <bean id="cronTrigger"  
        class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">  
  
        <!-- 指向我们的任务 -->  
        <property name="jobDetail" ref="job1" />  
  
        <property name="cronExpression" value="0 0/1 * * * ?" />  
       
    </bean>  
    
      <bean  
        class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
        <property name="triggers">  
            <list>  
                <!--  触发器列表 -->  
                <ref bean="cronTrigger" />  
            </list>  
        </property>  
    </bean>  

BusinessJob.java

public class BusinessJob extends QuartzJobBean{

	@Override
	protected void executeInternal(JobExecutionContext jobexecutioncontext)
			throws JobExecutionException {
		 
		System.out.println("execute hello!!");
	}
 
}