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

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

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="logBeforeAdvice" class="com.hwp.aop.pa.BeforeAdviceDemo" />
    <bean id="helloAdvisor"
        class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
        <property name="mappedName" value="hello*" />
        <property name="advice" ref="logBeforeAdvice" />
    bean>
    <bean id="helloSpeaker" class="com.hwp.aop.pa.HelloSpeaker" />
    <bean id="helloProxy"
        class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces" value="com.hwp.aop.pa.IHello" />
        <property name="target" ref="helloSpeaker" />
        <property name="interceptorNames">
            <list>
                <value>helloAdvisorvalue>
            list>
        property>
    bean>
beans>

惠万鹏 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:

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="logBeforeAdvice"
        class="com.hwp.aop.adviceDemo.BeforeAdviceDemo" />
    <bean id="logAfterAdvice"
        class="com.hwp.aop.adviceDemo.AfterAdviceDemo" />
    <bean id="logRoundAdvice"
        class="com.hwp.aop.adviceDemo.AroundAdviceDemo" />
    <bean id="throwAdvice"
        class="com.hwp.aop.adviceDemo.ThowAdviceDemo" />
    <bean id="helloSpeaker" class="com.hwp.aop.adviceDemo.HelloSpeaker" />
    <bean id="helloProxy"
        class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces"
            value="com.hwp.aop.adviceDemo.IHello" />
        <property name="target" ref="helloSpeaker" />
        <property name="interceptorNames">
            <list>
                <value>logBeforeAdvicevalue>
                <value>logAfterAdvicevalue>
                <value>logRoundAdvicevalue>
                <value>throwAdvicevalue>
            list>
        property>
    bean>
beans>

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.动态代理，代理对象必须实现java.lang.reflect.InvacationHandler接口，对服务的目标对象的类型不限。

目标对象接口如下：

package com.hwp.aop.staticProxy;

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

目标对象如下：

package com.hwp.aop.staticProxy;

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

静态代理如下：

package com.hwp.aop.staticProxy;

import java.util.logging.Level;
import java.util.logging.Logger;

public class HelloProxy {
    private Logger logger = Logger.getLogger(this.getClass().getName());
    private IHello helloSpeaker;

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

    public void hello(String name) {
        logger.log(Level.INFO, "hello,method starts.");
        this.helloSpeaker.hello(name);
        logger.log(Level.INFO, "hello,method end.");
    }

    public void log(String msg){
        logger.log(Level.INFO, msg);
    }
    public static void main(String[] args){
        HelloProxy hp = new HelloProxy(new HelloSpeaker());
        hp.hello("惠万鹏");
    }
}

动态代理如下：

package com.hwp.aop.dynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.hwp.aop.staticProxy.HelloSpeaker;
import com.hwp.aop.staticProxy.IHello;

public class LogHandler implements InvocationHandler{
    private Logger logger = Logger.getLogger(this.getClass().getName());
    private Object delegate;
    public Object bind(Object delegate){
        this.delegate = delegate;
        return Proxy.newProxyInstance(delegate.getClass().getClassLoader(),delegate.getClass().getInterfaces(),this);
    }
    public Object invoke(Object proxy, Method method, Object[] arg)
            throws Throwable {
        Object result = null;
        try{
            this.log("method starts" + method);
            result = method.invoke(this.delegate, arg);
        }catch(Exception e){
            this.log(e.toString());
        }
        return result;
    }
    private void log(String msg){
        logger.log(Level.INFO, msg);
    }
    public static void main(String[] args){
        LogHandler logHandler = new LogHandler();
        IHello helloProxy = (IHello) logHandler.bind(new HelloSpeaker());
        helloProxy.hello("惠万鹏");
    }
}

惠万鹏 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 发表评论