BlogJava-梦幻之旅-随笔分类-Spring

spring 属性文件加密码及解密

惠万鹏 — Mon, 19 Jul 2010 09:22:00 GMT

摘要: 加密类: package com.framework.commons.util; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStrea... 阅读全文

惠万鹏 2010-07-19 17:22 发表评论

acegi基于数据库存储用户的身份认证

惠万鹏 — Mon, 01 Sep 2008 15:18:00 GMT

xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

    <bean id="dataSource"
        class="com.mchange.v2.c3p0.ComboPooledDataSource"
        destroy-method="close">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl"
            value="jdbc:mysql://127.0.0.1:3306/mydata" />
        <property name="user" value="root" />
        <property name="password" value="root" />
        <property name="autoCommitOnClose" value="true" />
        <property name="checkoutTimeout" value="5000" />
        <property name="initialPoolSize" value="2" />
        <property name="minPoolSize" value="2" />
        <property name="maxPoolSize" value="4" />
        <property name="maxIdleTime" value="25200" />
        <property name="acquireIncrement" value="1800" />
        <property name="maxIdleTimeExcessConnections" value="5" />
    bean>
    <bean id="filterChainProxy"
        class="org.acegisecurity.util.FilterChainProxy">
        <property name="filterInvocationDefinitionSource">
            <value>
                CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
                PATTERN_TYPE_APACHE_ANT
                /**=authenticationProcessingFilter
            value>
        property>
    bean>
    <bean id="authenticationProcessingFilter"
        class="org.acegisecurity.ui.webapp.AuthenticationProcessingFilter">
        <property name="filterProcessesUrl"
            value="/j_acegi_security_check" />
        <property name="defaultTargetUrl" value="/main.jsp" />
        <property name="authenticationFailureUrl"
            value="/index.jsp?login_error=1" />
        <property name="authenticationManager"
            ref="authenticationManager" />
    bean>
    <bean id="authenticationManager"
        class="org.acegisecurity.providers.ProviderManager">
        <property name="providers">
            <list>
                <ref local="daoAuthenticationProvider" />
            list>
        property>
    bean>
    <bean id="daoAuthenticationProvider"
        class="org.acegisecurity.providers.dao.DaoAuthenticationProvider">
        <property name="userDetailsService" ref="userDetailsService" />
    bean>

    <bean id="userDetailsService" class="org.acegisecurity.userdetails.jdbc.JdbcDaoImpl">
        <property name="dataSource" ref="dataSource" />
        <property name="usersByUsernameQuery">
            <value>SELECT username,password,status FROM t_user WHERE username=?value>
        property>
        <property name="authoritiesByUsernameQuery">
            <value>SELECT u.username,p.priv_name FROM t_user u,t_user_priv p WHERE u.user_id=p.user_id and u.username=?value>
        property>
    bean>


beans>

惠万鹏 2008-09-01 23:18 发表评论

acegi基于内存存储用户的身份认证

惠万鹏 — Tue, 26 Aug 2008 16:18:00 GMT

web.xml

xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    <context-param>
        <param-name>contextConfigLocationparam-name>
        <param-value>
            classpath:applicationContext-acegi-plugin.xml
        param-value>
    context-param>
    <filter>
        <filter-name>AcegiFilterChainProxyfilter-name>
        <filter-class>
            org.acegisecurity.util.FilterToBeanProxy
        filter-class>
        <init-param>
            <param-name>targetClassparam-name>
            <param-value>
                org.acegisecurity.util.FilterChainProxy
            param-value>
        init-param>
    filter>
    <filter-mapping>
        <filter-name>AcegiFilterChainProxyfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        listener-class>
    listener>
web-app>

applicationContext-acegi-plugin.xml

index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>
DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>测试title>
    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http-equiv="description" content="This is my page">

  head>
  <body>
    <form name="meForm" method="post" action="/j_acegi_security_check">
        用户名:<input type="text" name="j_username"/> <br />
        密  码:<input type="text" name="j_password"/> <br />
        <input type="submit" value="登陆"/>
    form>
  body>
html>

惠万鹏 2008-08-27 00:18 发表评论

spring 里配置 quartz

惠万鹏 — Tue, 19 Aug 2008 14:59:00 GMT

package hvp.spring.quartz.bean;

import java.util.Map;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.context.ApplicationContext;

public class MyJob implements Job
{

    @SuppressWarnings("unchecked")
    public void execute(JobExecutionContext jec) throws JobExecutionException
    {
        Map dataMap = jec.getJobDetail().getJobDataMap();
        String size = (String) dataMap.get("size");
        // 得到Spring的ApplicationContext,可以访问Spring里的任何Bean了.
        ApplicationContext ac = (ApplicationContext) dataMap
                .get("applicationContext");
        System.out.println(size + ":工作里" + ac.toString());
    }
}

package hvp.spring.quartz.bean;

public class MyService
{
    public void doJob()
    {
        System.out.println("in MyService.doJob().");
    }
}

package hvp.spring.quartz.bean;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestQuartx
{
    public static void main(String[] args){
        String configPath = "hvp/spring/quartz/bean/quartzBean.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
        ctx.getBean("scheduler");
    }
}

xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
    <bean name="jobDetail"
        class="org.springframework.scheduling.quartz.JobDetailBean">
        <property name="jobClass"
            value="hvp.spring.quartz.bean.MyJob" />
        <property name="jobDataAsMap">
            <map>
                <entry key="size" value="10" />
            map>
        property>
        <property name="applicationContextJobDataKey"
            value="applicationContext" />
    bean>
    <bean id="jobDetail_1"
        class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="myService" />
        <property name="targetMethod" value="doJob" />
        <property name="concurrent" value="false" />
    bean>
    <bean id="myService" class="hvp.spring.quartz.bean.MyService" />
    <bean id="simpleTrigger"
        class="org.springframework.scheduling.quartz.SimpleTriggerBean">
        <property name="jobDetail" ref="jobDetail" />
        <property name="startDelay" value="1000" />
        <property name="repeatInterval" value="1000" />
        <property name="repeatCount" value="1000" />
        <property name="jobDataAsMap">
            <map>
                <entry key="count" value="10" />
            map>
        property>
    bean>
    <bean id="checkImagesTrigger"
        class="org.springframework.scheduling.quartz.CronTriggerBean">
        <property name="jobDetail" ref="jobDetail_1" />
        <property name="cronExpression" value="0/5 * * * * ?" />
    bean>
    <bean id="scheduler"
        class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="checkImagesTrigger" />
                <ref bean="simpleTrigger" />
            list>
        property>
        <property name="schedulerContextAsMap">
            <map>
                <entry key="timeout" value="30" />
            map>
        property>
        <property name="quartzProperties">
            <props>
                <prop key="org.quartz.threadPool.class">
                    org.quartz.simpl.SimpleThreadPool
                prop>
                <prop key="org.quartz.threadPool.threadCount">10prop>
            props>
        property>
    bean>
beans>

惠万鹏 2008-08-19 22:59 发表评论

HibernateTemplate DAO

惠万鹏 — Mon, 18 Aug 2008 13:21:00 GMT

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class UserDAO extends HibernateDaoSupport
{
    public void addUser(User user)
    {
        this.getHibernateTemplate().save(user);
    }

    public void updateUser(User entity)
    {
        this.getHibernateTemplate().save(entity);
    }

    public void deleteUser(User entity)
    {
        this.getHibernateTemplate().delete(entity);
    }

    public User getUser(int entityId)
    {
        return (User) this.getHibernateTemplate().get(User.class, entityId);
    }

    @SuppressWarnings("unchecked")
    public List<User> findUsers()
    {
        return getHibernateTemplate().executeFind(new HibernateCallback()
            {
                @SuppressWarnings("unchecked")
                public List<User> doInHibernate(Session session)
                        throws HibernateException, SQLException
                {
                    StringBuffer sql = new StringBuffer(
                            "from User u where 1=1 ");
                    Query query = session.createQuery(sql.toString());
                    List<User> users = query.list();
                    return users;
                }
            });
    }

    public Long getUserNum()
    {
        return (Long) getHibernateTemplate().execute(new HibernateCallback()
            {
                public Long doInHibernate(Session session)
                        throws HibernateException, SQLException
                {
                    Query query = session
                            .createQuery("SELECT COUNT(u.userId) FROM User u");
                    return (Long) query.uniqueResult();
                }
            });
    }

    public static void main(String[] a)
    {
        User user = new User();
        user.setUserName("hwpokay");
        user.setSex(0);

        String configPath = "hvp/spring/hibernate/orm/beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);

        UserDAO userDAO = (UserDAO) ctx.getBean("userDAO");
        System.out.println(userDAO.getUserNum());
    }
}

惠万鹏 2008-08-18 21:21 发表评论

HibernateTemplate

惠万鹏 — Thu, 14 Aug 2008 00:01:00 GMT

xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/hwpok" />
        <property name="user" value="mydata" />
        <property name="password" value="root" />
        <property name="autoCommitOnClose" value="true"/>
        <property name="checkoutTimeout" value="5000"/>
        <property name="initialPoolSize" value="2"/>
        <property name="minPoolSize" value="2"/>
        <property name="maxPoolSize" value="4"/>
        <property name="maxIdleTime" value="25200"/>
        <property name="acquireIncrement" value="1800"/>
        <property name="maxIdleTimeExcessConnections" value="5"/>
    bean>
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="mappingDirectoryLocations">
            <list>
                <value>classpath:/hvp.spring.hibernate.ormvalue>
            list>
        property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialectprop>
                <prop key="hibernate.show_sql">trueprop>
                <prop key="hibernate.generate_statistics">trueprop>
            props>
        property>
    bean>
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory" />
    bean>
    <bean id="userDAO" class="hvp.spring.hibernate.orm.UserDAO">
        <property name="hibernateTemplate" ref="hibernateTemplate" />
    bean>
beans>

hbm.xml

DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<hibernate-mapping package="hvp.spring.hibernate.orm">
    <class name="User" table="le_users">
        <id name="userId" column="user_id">
            <generator class="increment" />
        id>
        <property name="userName" column="user_name" />
        <property name="sex" column="sex" />
    class>
hibernate-mapping>

dao

package hvp.spring.hibernate.orm;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class UserDAO extends HibernateDaoSupport
{
    public void addUser(User user){
        this.getHibernateTemplate().save(user);
    }

    public static void main(String[] a){
        User user = new User();
        user.setUserName("hwpokay");
        user.setSex(0);

        String configPath = "hvp/spring/aspectj/anno/beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);

        UserDAO userDAO = (UserDAO)ctx.getBean("userDAO");
        userDAO.addUser(user);
    }
}

惠万鹏 2008-08-14 08:01 发表评论

Spring JdbcTemplate

惠万鹏 — Sun, 10 Aug 2008 09:46:00 GMT

package hvp.spring.jdbc.jdbctemplate;

import hvp.spring.commons.inim.UserPO;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;

public class UserDAO
{
    JdbcTemplate jt;

    public UserDAO()
    {
        this.jt = this.getJdbcTemplate2();
    }

    public JdbcTemplate getJdbcTemplate2()
    {
        String configPath = "hvp/spring/jdbc/jdbctemp/beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
        return (JdbcTemplate) ctx.getBean("jdbcTemplate");
    }

    public void createTable()
    {
        StringBuffer sql = new StringBuffer();
        sql.append("CREATE TABLE t_user(");
        sql.append("user_id int AUTO_INCREMENT PRIMARY KEY,");
        sql.append("user_name VARCHAR(32)");
        sql.append(")");
        jt.execute(sql.toString());
    }

    public UserPO addUser(final UserPO po)
    {
        final String sql = "INSERT INTO t_user(user_name) VALUES (?)";
        KeyHolder keyHolder = new GeneratedKeyHolder();
        jt.update(new PreparedStatementCreator()
            {
                public PreparedStatement createPreparedStatement(Connection conn)
                        throws SQLException
                {
                    PreparedStatement ps = conn.prepareStatement(sql);
                    ps.setString(1, po.getUserName());
                    return ps;
                }
            }, keyHolder);
        po.setUserId(keyHolder.getKey().intValue());
        System.out.println(po.getUserId() + ":" + po.getUserName());
        return po;
    }

    @SuppressWarnings("unchecked")
    public List<UserPO> queryUserPOs()
    {
        StringBuffer sql = new StringBuffer();
        sql.append("SELECT user_id,user_name FROM t_user");
        sql.append(" LIMIT ");
        sql.append(0);
        sql.append(",");
        sql.append(10);

        return jt.query(sql.toString(), new RowMapper()
            {
                public Object mapRow(ResultSet rs, int index)
                        throws SQLException
                {
                    UserPO userPO = new UserPO();
                    userPO.setUserId(rs.getInt("user_id"));
                    userPO.setUserName(rs.getString("user_name"));
                    return userPO;
                }
            });
    }

    public UserPO findUser(Integer userId)
    {
        String sql = "SELECT user_id,user_name FROM t_user WHERE user_id=?";
        return (UserPO) jt.queryForObject(sql, new Object[] { userId },
                new RowMapper()
                    {
                        public Object mapRow(ResultSet rs, int index)
                                throws SQLException
                        {
                            UserPO userPO = new UserPO();
                            userPO.setUserId(rs.getInt("user_id"));
                            userPO.setUserName(rs.getString("user_name"));
                            return userPO;
                        }
                    });
    }

    public int getCount()
    {
        String sql = "SELECT COUNT(*) FROM t_user";
        return jt.queryForInt(sql);
    }

    public static void main(String[] args)
    {
        UserDAO ct = new UserDAO();
        // UserPO user = new UserPO();
        // user.setUserName("Huy Vanlee");
        // ct.addUser(user);
        System.out.println(ct.queryUserPOs());
    }
}

惠万鹏 2008-08-10 17:46 发表评论

再温 c3p0 连接池

惠万鹏 — Sun, 10 Aug 2008 04:36:00 GMT

测试:

package hvp.spring.jdbc.jdbctemp;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

public class CreateTable
{
    JdbcTemplate jt;

    public CreateTable()
    {
        this.jt = this.getJdbcTemplate2();
    }

    public JdbcTemplate getJdbcTemplate()
    {
        DriverManagerDataSource dmds = new DriverManagerDataSource();
        dmds.setDriverClassName("com.mysql.jdbc.Driver");
        dmds.setUrl("jdbc:mysql://localhost:3306/hwpok");
        dmds.setUsername("hwpok");
        dmds.setPassword("123456");

        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dmds);
        return jdbcTemplate;
    }

    public JdbcTemplate getJdbcTemplate2()
    {
        String configPath = "hvp/spring/jdbc/jdbctemp/beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
        return (JdbcTemplate) ctx.getBean("jdbcTemplate");
    }

    public void createTable()
    {
        StringBuffer sql = new StringBuffer();
        sql.append("CREATE TABLE t_user(");
        sql.append("user_id int primary key,");
        sql.append("user_name varchar(32)");
        sql.append(")");
        jt.execute(sql.toString());
    }

    public static void main(String[] args)
    {
        CreateTable ct = new CreateTable();
        ct.createTable();
    }
}

惠万鹏 2008-08-10 12:36 发表评论

使用 @AspectJ 的一个例子

惠万鹏 — Sat, 26 Jul 2008 06:27:00 GMT

    首先,要求JDK版本为5以上,且需要导入以下9个包:
    1.asm-2.2.3.jar
    2.asm-commons-2.2.3.jar
    3.asm-util-2.2.3.jar
    4.aspectjrt.jar
    5.aspectjweaver.jar
    6.log4j-1.2.14.jar
    7.commons-logging.jar
    8.cglib-nodep-2.1_3.jar
    9.spring.jar
    还是以前面的HelloSpeaker为例子:

package org.hvp.aspect;

public class HelloSpeaker {
    public void hello(String name) {
        System.out.print("Hi," + name);
    }
}

使用@AspectJ

package org.hvp.aspect;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.aop.aspectj.annotation.AspectJProxyFactory;

@Aspect
public class HelloSpeakerProxy {
    @After("execution(* hello(..))")
    public void welcome() {
        System.out.println(", welcome to our pub.");
    }

    public HelloSpeaker getHelloSpeakerProxy() {
        AspectJProxyFactory factory = new AspectJProxyFactory();
        factory.setTarget(new HelloSpeaker());
        factory.addAspect(HelloSpeakerProxy.class);
        return factory.getProxy();
    }

    public static void main(String[] args) {
        HelloSpeakerProxy proxy = new HelloSpeakerProxy();
        HelloSpeaker helloSpeaker = proxy.getHelloSpeakerProxy();
        helloSpeaker.hello("Huy Vanpom");
    }
}

惠万鹏 2008-07-26 14:27 发表评论

jar 包说明总结

惠万鹏 — Sat, 26 Jul 2008 06:15:00 GMT

1.asm.jar,asm-commons.jar,asm-util.jar.
     asm是一个轻量级字节码处理和分析框架.

2.aspectjrt.jar,aspectjweaver.jar
    Aspect提供的注释类库和相应的解析类库

3.commons-loging.jar
   Common Log 是更通用、简单的log工具，用于屏蔽底层具体的细节，底层完全可以使用Log4J或jdk1.4 log包

惠万鹏 2008-07-26 14:15 发表评论

从注释类型到 @AspectJ

惠万鹏 — Fri, 25 Jul 2008 03:48:00 GMT

本练习有三个目标:
1.如何定义注释类型
2.如何使用注释类型
3.如何让注释影响程序运行

一.如何定义注释类型

package org.test.spring.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
*

* 定义一个Person类专用的注释
*

* 元注释Retention用于指定此注释类型的注释要保留多久, 元注释Target用于指定此注释类型的注释适用的程序元素的种类,
*
* @author Huy Vanpon
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Annot4Person
{
    String name() default "惠万鹏";

    int age() default 25;

    String gender() default "男";
}

二.2.如何使用注释类型

package org.test.spring.annotation;

/**
*

* 本类用于定义人类,包含一个自我介绍的方法
*

*
* @author Huy Vanpon
*/
public class Person
{
    @Annot4Person(name = "何洁", gender = "女", age = 16)
    public void introductionMyself(String name, String gender, int age)
    {
        StringBuffer sb = new StringBuffer();
        sb.append("嗨,大家好,我叫");
        sb.append(name);
        sb.append(",今年");
        sb.append(age);
        sb.append("岁，是一个充满阳光的");
        sb.append(gender);
        sb.append("孩.");
        System.out.println(sb.toString());
    }
}

三.如何让注释影响程序运行

package org.test.spring.annotation;

import java.lang.reflect.Method;

/**
*

* 本用利JAVA的反射机制,让注释影响程序的运行
*

*
* @author Huy Vanpon
*/
public class AnnotDisturber
{
    public void testAnnot4Person()
    {
        Class<Person> clazz = Person.class;
        try
        {
            //通过方法名和入参确定方法
            Method method = clazz.getDeclaredMethod("introductionMyself",
                    String.class, String.class, int.class);
            if (method == null)
            {
                return;
            }
            //从方法取得注释
            Annot4Person annotation = method.getAnnotation(Annot4Person.class);
            if (annotation == null)
            {
                return;
            }
            //调用这个方法
            method.invoke(new Person(), annotation.name(), annotation.gender(),
                    annotation.age());
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    public static void main(String[] args)
    {
        AnnotDisturber tt = new AnnotDisturber();
        tt.testAnnot4Person();
    }
}

惠万鹏 2008-07-25 11:48 发表评论

Spring 下几种连接池的比较

惠万鹏 — Wed, 16 Apr 2008 02:30:00 GMT

我推荐proxool，因为他不但可以监控后台。还可以有效的释放连接。在connection close时，也就是归还connection，
关闭所有的statement，并且判断是否autocommit，如果不行，就rollback，并且设置true，
可以参考proxool的org.logicalcobwebs.proxool.ConnectionResetter类
connection pool把connection reset置回initial state。
dbcp的配置

SELECT 1

true

c3p0的配置，注意是''driverClass' , 'jdbcUrl', 'user' , 'password'

        net.sourceforge.jtds.jdbc.Driver

jdbc:jtds:sqlserver://localhost:1433/hua


        sa


        hua


        15


        5


        25

或

        destroy-method="close">

            ${db.driverClass}


            ${db.url}




                5
                100
                100
                0
                10
                ${db.user}
                ${db.pass}



xapool的配置



        com.mysql.jdbc.Driver
        jdbc:mysql://localhost/dbname


    root
    mypass
    1
    5
    select 1

c-jdbc的配置

    jdbc:cjdbc://127.0.0.1:25322/vdb?user=vuser

weblogic的连接池解决办法:Test Reserved Connections: 如果选择了这个选项，服务器会在把连接提供给客户端之前
对其进行测试。 Test Created Connections: 如果选择了这个选项，就会在创建一个JDBC
连接之后和在把它添加到JDBC连接池中的可用连接列表之前，对该JDBC连接进行测试。

tomcat的jndi关于dbcp的配置:

         factory
         org.apache.commons.dbcp.BasicDataSourceFactory


         driverClassName
         com.sybase.jdbc2.jdbc.SybDriver


         url
         xyz


         username
         xyz


         password
         xyz


         maxActive
         5


         maxIdle
         5


         maxWait
         -1


         removeAbandoned
         true


         validationQuery
         select count(*) from sometable where 1 = 0


         testOnBorrow
         true

proxool

      newstest
      net.sourceforge.jtds.jdbc.Driver
      jdbc:jtds:sqlserver://127.0.0.1:1433/news
      sa
      1
      90000
      5
      100
      10
      true
      true

惠万鹏 2008-04-16 10:30 发表评论

AOP NameMatchMethodPointcutAdvisor

惠万鹏 — Tue, 15 Apr 2008 12:54:00 GMT

惠万鹏 2008-04-15 20:54 发表评论

AOP Before Advice After Advice Around Advice Throw Advice

惠万鹏 — Sun, 13 Apr 2008 06:37:00 GMT

Before Advice:

package com.hwp.aop.adviceDemo;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class BeforeAdviceDemo implements MethodBeforeAdvice {

    public void before(Method method, Object[] args, Object target)
            throws Throwable {
        System.out.println("在方法运行前，先运行");
    }

}

After Advice:

package com.hwp.aop.adviceDemo;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

public class AfterAdviceDemo implements AfterReturningAdvice{

    public void afterReturning(Object arg0, Method arg1, Object[] arg2,
            Object arg3) throws Throwable {
        System.out.println("方法执行后.");

    }

}

Round Advice:

package com.hwp.aop.adviceDemo;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class AroundAdviceDemo implements MethodInterceptor {

    public Object invoke(MethodInvocation arg0) throws Throwable {
        System.out.println("在round方法里，方法开始前..");
        Object result = null;
        try {
            result = arg0.proceed();
        } finally {
            System.out.println("在round方法里，方法结束后");
        }
        return result;
    }

}

Throw Advice:

package com.hwp.aop.adviceDemo;

import java.lang.reflect.Method;

import org.springframework.aop.ThrowsAdvice;

public class ThowAdviceDemo implements ThrowsAdvice {
    public void afterThrowing(Method method, Object[] args, Object target,
            Throwable subclass) {
        System.out.println("异常抛出后..");
    }

}

beans.xml:

Demo:

package com.hwp.aop.adviceDemo;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringAOPDemo {
    public static void main(String[] args){
        ApplicationContext context =
            new ClassPathXmlApplicationContext("beans-beforeAdvice.xml");
        IHello helloProxy = (IHello) context.getBean("helloProxy");
        try{
            helloProxy.hello("惠万鹏");
        }catch(Exception e){
            //e.printStackTrace();
        }
    }
}

收工....

惠万鹏 2008-04-13 14:37 发表评论

从代理机制到 AOP

惠万鹏 — Sat, 12 Apr 2008 16:07:00 GMT

AOP(面向方面编程)是一种新的编程技术,它能够将那些本不应该纠缠在一起的任务分离开,从而为程序提供更好的封装性和互操作性.
AOP是通过代理机制实现的.
代理是指为其他对象提供一种代理以控制对这个对象的访问.
代理分为三种：
    1.静态代理，代理对象必须实现目标对象的接口，且一个接口只服务于一种类型的目标对象。
    2.JDK动态代理，代理对象必须实现java.lang.reflect.InvacationHandler接口，只能为接口创建代理实例。
    3.CGLib动态代理，使用非常底层的字节码技术,可以为任何对象创建代理.

以下是目标对象接口和目标对象.
目标对象接口如下:

package org.test.spring.aop;

public interface IHello
{
public void hello(String name);
}

目标对象如下:

package org.test.spring.aop;

public class HelloSpeaker implements IHello
{
    public void hello(String name)
    {
        System.out.print("Hi," + name);
    }
}

一.静态代理
静态代理比较容易理解,静态代理其实很容易理解，静态代理其实就是个装饰器而已.
让代理对象也实现目标对像的接口,这样做的目的是让使用者在使用代理对象时感觉不到代理对象的存在.
代理对象如下:

package org.test.spring.aop;

public class HelloSpeakerProxy implements IHello
{
    private IHello helloSpeaker;

    public HelloSpeakerProxy(IHello helloSpeaker)
    {
        this.helloSpeaker = helloSpeaker;
    }

    public void hello(String name)
    {
        this.helloSpeaker.hello(name);
        System.out.println(", welcome to our pub.");
    }

    public static void main(String[] args)
    {
        IHello helloSpeaker = new HelloSpeaker();
        IHello proxy = new HelloSpeakerProxy(helloSpeaker);
        proxy.hello("Huy Vanpon");
    }
}

二.JDK动态代理
所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

package org.test.spring.aop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class HelloSpeakerProx implements InvocationHandler
{

    private Object target;

    public Object invoke(Object proxy, Method method, Object[] parameters)
            throws Throwable
    {
        Object object = null;
        try
        {
            object = method.invoke(target, parameters);
            System.out.println(", welcome to our pub.");
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return object;
    }

    /**
     *

* 这个方法用于得到代理对象
*

     *
     * @param target
     *            目标对象
     * @return result(Object)代理对象
     */
    public Object getProxy(Object target)
    {
        this.target = target;
        /**
         * newProxyInstance(ClassLoader loader, Class[] interfaces,
         * InvocationHandler invocationHandler) loader: 定义代理类的加加载器(目标类的加载器)
         * interfaces: 代理类要实现的接口列表 invocationHandler: 指派方法调用的调用处理程序
         */
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }

    public static void main(String[] args)
    {
        IHello proxy = (IHello) new HelloSpeakerProx()
                .getProxy(new HelloSpeaker());
        proxy.hello("Huy Vanpon");
    }
}

三.CGLib动态代理
使用jdk创建代理有一个限制,即它只能为接口创建代理实例.CGLib使用非常底层的字节码技术,可以为一个类创建子类,并在子类中采用方法拦截的拦截技术,并顺势织入横切逻辑.
运行这个例子,一定要记得导入CGLib相应的包哦..

package org.test.spring.aop;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class HelloSpeakerPro implements MethodInterceptor
{
    private Enhancer enhancer = new Enhancer();

    public Object getProxy(Class clazz)
    {
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    public Object intercept(Object object, Method method, Object[] args,
            MethodProxy proxy) throws Throwable
    {
        Object result = null;
        result = proxy.invokeSuper(object, args);
        System.out.println(", welcome to our pub.");
        return result;
    }

    public static void main(String[] args)
    {
        HelloSpeakerPro helloSpeakerPro = new HelloSpeakerPro();
        HelloSpeaker helloSpeaker = (HelloSpeaker) helloSpeakerPro
                .getProxy(HelloSpeaker.class);
        helloSpeaker.hello("Huy Vanpon");
    }

}

惠万鹏 2008-04-13 00:07 发表评论

Spring Ioc AOP

惠万鹏 — Tue, 08 Apr 2008 15:26:00 GMT

IoC:
    协调领带对象之间合作的责任从对象自身中转移出来，从而降低对象和对象之间的耦合。
    IoC意味着关于对象如何得到它的协作对象的责任反转了。
AOP:
    AOP经常被定义为一种编程技术，用来在系统中提升业务的分离，使这些组件更加专注于他自己的业务.

惠万鹏 2008-04-08 23:26 发表评论

Spring 是什么

惠万鹏 — Thu, 03 Apr 2008 02:27:00 GMT

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

• 目的：解决企业应用开发的复杂性

• 功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

• 范围：任何Java应用

简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

■ 轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

■ 控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

■ 面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

■ 容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

■ 框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

Spring简介
关于Spring Framework，今年夏天你可能已经听见很多的议论。在本文中,我将试图解释Spring能完成什么，和我怎么会认为它能帮助你开发J2EE应用程序。

另一framework？
你可能正在想“不过是另外一个的framework”。当已经有许多开放源代码(和专有) J2EE framework时，为什么你应该费心读这篇文章,或下载Spring Framework？

我相信Spring是独特的,因为若干个原因:
. 它定位的领域是许多其他流行的framework没有的。Spring关注提供一种方法管理你的业务对象。
. Spring是全面的和模块化的。Spring有分层的体系结构,这意味着你能选择使用它孤立的任何部分,它的架构仍然是内在稳定的。因此从你的学习中，你可得到最大的价值。例如,你可能选择仅仅使用Spring来简单化JDBC的使用,或用来管理所有的业务对象。
. 它的设计从底部帮助你编写易于测试的代码。Spring是用于测试驱动工程的理想的framework。

Spring对你的工程来说，它不需要一个以上的framework。Spring是潜在地一站式解决方案,定位于与典型应用相关的大部分基础结构。它也涉及到其他framework没有考虑到的内容。

尽管它仅仅是一个从2003年2月才开始的开源工程，但Spring有较长的历史根基。这个开源工程是起源自我在2002年后期出版的《Expert One-on-One J2EE设计与开发》书中的基础代码。这本书展示了Spring背后的基础架构。然而,这个基础架构的概念要追溯到2000年的早些时候,并且反映了我为一系列成功的商业工程开发基础结构的经验。

从2003年1月，Spring已经落户于SourceForge上。现在有10个开发人员,其中6是高度投入的积极分子。

Spring的架构性的好处

在我们进入细节以前，让我们看一下Spring可以给一个工程带来的一些好处:

. Spring能有效地组织你的中间层对象,无论你是否选择使用了EJB。如果你仅仅使用了Struts或其他的包含了J2EE特有APIs的framework，你会发现Spring关注了遗留下的问题，。

. Spring能消除在许多工程上对Singleton的过多使用。根据我的经验，这是一个主要的问题，它减少了系统的可测试性和面向对象特性。

. Spring能消除使用各种各样格式的属性定制文件的需要,在整个应用和工程中，可通过一种一致的方法来进行配置。曾经感到迷惑，一个特定类要查找迷幻般的属性关键字或系统属性,为此不得不读Javadoc乃至源编码吗？有了Spring，你可很简单地看到类的JavaBean属性。倒置控制的使用(在下面讨论)帮助完成这种简化。

. Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。
. Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。
. 使用Spring构建的应用程序易于单元测试。
. Spring能使EJB的使用成为一个实现选择,而不是应用架构的必然选择。你能选择用POJOs或local EJBs来实现业务接口，却不会影响调用代码。
. Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适于许多web应用。例如,Spring能使用AOP提供声明性事务而不通过使用EJB容器，如果你仅仅需要与单个的数据库打交道，甚至不需要JTA实现。
. Spring为数据存取提供了一致的框架,不论是使用JDBC或O/R mapping产品（如Hibernate）。
Spring确实使你能通过最简单可行的解决办法解决你的问题。这些特性是有很大价值的。

Spring能做什么？

Spring提供许多功能,在此我将快速地依次展示其各个主要方面。

任务描述：
首先,让我们明确Spring范围。尽管Spring覆盖了许多方面，但我们已经有清楚的概念，它什么应该涉及和什么不应该涉及。

Spring的主要目的是使J2EE易用和促进好编程习惯。
Spring不重新开发已有的东西。因此，在Spring中你将发现没有日志记录的包,没有连接池,没有分布事务调度。这些均有开源项目提供(例如Commons Logging 用来做所有的日志输出，或Commons DBCP用来作数据连接池),或由你的应用程序服务器提供。因为同样的的原因，我们没有提供O/R mapping层，对此，已有有好的解决办法如Hibernate和JDO。

Spring的目标是使已存在的技术更加易用。例如,尽管我们没有底层事务协调处理，但我们提供了一个抽象层覆盖了JTA或任何其他的事务策略。

Spring没有直接和其他的开源项目竞争，除非我们感到我们能提供新的一些东西。例如，象许多开发人员，我们从来没有为Struts高兴过，并且感到在MVC web framework中还有改进的余地。在某些领域，例如轻量级的IoC容器和AOP框架，Spring有直接的竞争，但是在这些领域还没有已经较为流行的解决方案。(Spring在这些区域是开路先锋。)

Spring也得益于内在的一致性。
所有的开发者都在唱同样的的赞歌,基础想法依然是Expert One-on-One J2EE设计与开发的那些。
并且我们已经能够使用一些主要的概念,例如倒置控制，来处理多个领域。

Spring在应用服务器之间是可移植的。
当然保证可移植性总是一次挑战，但是我们避免任何特定平台或非标准化,并且支持在WebLogic，Tomcat，Resin，JBoss，WebSphere和其他的应用服务器上的用户。

惠万鹏 2008-04-03 10:27 发表评论