BlogJava-Skynet-随笔分类-Spring

spring 与 hibernate 整合(事务)

G_G — Fri, 09 May 2008 05:47:00 GMT

参考：第 9 章事务管理 - Spring Framework reference 2.0.5 参考手册中文版
http://doc.javanb.com/spring-framework-reference-zh-2-0-5/ch09.html

先从配置文件开始：
源码：springAop.rar

需要jar

xml version="1.0" encoding="UTF-8"?>
<classpath>
    <classpathentry kind="src" path="java"/>
    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
    <classpathentry kind="lib" path="lib/aspectjrt.jar"/>
    <classpathentry kind="lib" path="lib/aspectjweaver.jar"/>
    <classpathentry kind="lib" path="lib/spring.jar"/>
    <classpathentry kind="lib" path="lib/spring-sources.jar"/>
    <classpathentry kind="lib" path="lib/commons-logging-1.0.4.jar"/>
    <classpathentry kind="lib" path="lib/cglib-nodep-2.1_3.jar"/>
    <classpathentry kind="lib" path="lib/hibernate3.jar"/>
    <classpathentry kind="lib" path="lib/log4j-1.2.11.jar"/>
    <classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
    <classpathentry kind="lib" path="lib/dom4j-1.6.1.jar"/>
    <classpathentry kind="lib" path="lib/commons-collections-2.1.1.jar"/>
    <classpathentry kind="lib" path="lib/mysql.jar"/>
    <classpathentry kind="lib" path="lib/jta.jar"/>
    <classpathentry kind="lib" path="lib/antlr-2.7.6.jar"/>
    <classpathentry kind="output" path="bin"/>
classpath>

spring 配置

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



  <bean id="beanDao" class="dao.imp.BeanDaoImp">
      <property name="sessionFactory">
          <ref bean="sessionFactory">ref>
      property>
  bean>



   <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

       <property name="configLocation" value="classpath:hibernate.cfg.xml" />
   bean>


   <aop:config>

         <aop:pointcut id="aopBean" expression="execution(* *.*.*(..))"/>
           <aop:advisor advice-ref="txAdvice" pointcut-ref="aopBean" />
      aop:config>


       <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
      <property name="sessionFactory" ref="sessionFactory" />
    bean>


      <tx:advice id="txAdvice" transaction-manager="txManager">
           <tx:attributes>
             <tx:method name="get*" read-only="true"/>
          <tx:method name="*" />
        tx:attributes>
      tx:advice>

beans>

hibernate 配置

xml version="1.0" encoding="UTF-8"?>
DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory name="asdf">
    <property name="hibernate.dialect">mysqlproperty>
    <property name="myeclipse.connection.profile">
        com.mysql.jdbc.Driver
    property>
    <property name="connection.url">
        jdbc:mysql://localhost/aop
    property>
    <property name="show_sql">trueproperty>

    <property name="connection.username">rootproperty>
    <property name="connection.password">property>
    <property name="connection.driver_class">
        com.mysql.jdbc.Driver
    property>
    <property name="dialect">
        org.hibernate.dialect.MySQLDialect
    property>

    <mapping resource="bean/UnitBean.hbm.xml" />

session-factory>
hibernate-configuration>

dao 类（接口）

package dao.imp;

import java.util.List;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import bean.UnitBean;

import dao.BeanDao;

public class BeanDaoImp extends HibernateDaoSupport implements BeanDao{
    public void addBean(UnitBean unitBean) {
        this.getHibernateTemplate().save(unitBean);
    }

    public List<UnitBean> getBeanByAll() {
        return this.getHibernateTemplate().find(" from "+UnitBean.class.getName());
    }

    public void removeBean(long beanId) {
        this.getHibernateTemplate().delete(
                getHibernateTemplate().get(UnitBean.class, beanId)
            );
    }

}

Main 类

package unit;

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

import dao.BeanDao;
import bean.UnitBean;

public class Main {
    public static void main(String[] args) {
           ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
           BeanDao dao = (BeanDao) ctx.getBean("beanDao");
           UnitBean bean = new UnitBean();
           bean.setName("xx");
           bean.setPass("11");
           dao.addBean(bean);

           for(UnitBean unitBean : dao.getBeanByAll() ){
               System.out.println( unitBean.getId() );
           }

           dao.removeBean(bean.getId());

    }
}

结果：
Hibernate: insert into bean (name, pass) values (?, ?)
Hibernate: select unitbean0_.id as id0_, unitbean0_.name as name0_, unitbean0_.pass as pass0_ from bean unitbean0_
1
Hibernate: select unitbean0_.id as id0_0_, unitbean0_.name as name0_0_, unitbean0_.pass as pass0_0_ from bean unitbean0_ where unitbean0_.id=?
Hibernate: delete from bean where id=?

G_G 2008-05-09 13:47 发表评论

spring AspectJ 基本使用

G_G — Thu, 08 May 2008 02:08:00 GMT

我的aop 基础

AOP(3)

spring 实际使用（这就使用一个例子说明）

测试类以及结果：

package unit;

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

import bean.HelloService;

public class Main {
    public static void main(String[] args) {
           ApplicationContext context = new ClassPathXmlApplicationContext(
                   "beans.xml");
           HelloService service = (HelloService) context.getBean("helloService");
           service.annotationAop();

           System.out.println();

           service.xmlAop();

    }
}
结果：
annotationAop//正常方法运行
aop--AspectJ! //annotation拦截

xmlAop //正常方法运行
aop--XmlAop! //配置拦截

use jar

--aspectjrt.jar
--aspectjweaver.jar
--acglib-nodep-2.1_3.jar
--commons-logging.jar
--spring.jar
--spring-aspects.jar

XML配置

<beans xmlns="http://www.springframework.org/schema/beans"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xmlns:aop="http://www.springframework.org/schema/aop"
               xsi:schemaLocation=
                   "http://www.springframework.org/schema/beans
                   http://www.springframework.org/schema/beans/spring-beans.xsd
                   http://www.springframework.org/schema/aop
                   http://www.springframework.org/schema/aop/spring-aop.xsd">


        <bean id="helloService"
            class="bean.HelloService"/>



        <bean id="xmlAop"
            class="aop.AnnotationAspectJ"/>
        <aop:aspectj-autoproxy/>



        <bean id="XmlAspectJ"
            class="aop.XmlAspectJ"/>
        <aop:config>
             <aop:aspect ref="XmlAspectJ">
                 <aop:pointcut id="mainMethod" expression="execution(* xmlAop(..))"/>
                 <aop:after-returning pointcut-ref="mainMethod" method="goXmlAop"/>
             aop:aspect>
         aop:config>

beans>

HelloService.java

package bean;

public class HelloService {
    public void annotationAop() {
        System.out.println(" annotationAop ");
    }

    public void xmlAop(){
        System.out.println(" xmlAop ");
    }
}

AnnotationAspectJ.java

package aop;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class AnnotationAspectJ {
    @Pointcut("execution(* annotationAop(..))")
    public void mainMethod() {}

    @AfterReturning("mainMethod()")
    public void sayHello() {
        System.out.println("aop--AspectJ!");
    }
}

XmlAspectJ.java

package aop;

public class XmlAspectJ {
    public void goXmlAop(){
        System.out.println(" aop--XmlAop! ");
    }
}

G_G 2008-05-08 10:08 发表评论

spring 学习笔记

G_G — Fri, 21 Dec 2007 08:33:00 GMT

我的春天spring 正式开始！^_^
spring项目基本需要jar->commons-logging.jar;log4j-1.2.9.jar;spring.jar
参考：http://www.redsaga.com/spring_ref/2.0/html/beans.html

本文主要内容：
1.单多配置文件的使用
2.动态替换类方法（cglib）
3.自定义作用域bean
4.定制bean特性

1).单多配置文件的使用
1.1)配置文件:beans.xml格式（基本配置）

xml version="1.0" encoding="UTF-8"?>
DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="userBean" name="userBean"
          class="springtest.UserBean"
          abstract="false"
          singleton="true"
          lazy-init="default"
          autowire="default"
          dependency-check="default" >
            <property name="name">
                <value>beavalue>
            property>
    bean>

beans>

spring 工厂建立单配置和多配置文件

    //单配置文件加载
    public void testSp()throws Exception{
        Resource res = new FileSystemResource(
            this.getClass().getClassLoader().getResource("config/beans.xml").getPath()
                );
        BeanFactory fac = new XmlBeanFactory(res);
        UserBean uu = (UserBean) fac.getBean("userBean");
        System.out.println(uu.getName());
        System.out.println(uu.getAge());
    }
    //多配置文件加载
    public void testSps() throws Exception {
        ApplicationContext act=new ClassPathXmlApplicationContext(
            new String[] {"config/beans.xml",.....}
        );
        UserBean uu = (UserBean)act.getBean("userBean");
        System.out.println( uu.getName());
    }

1.2) 还用一种是单配置多达到多配置

xml version="1.0" encoding="UTF-8"?>
DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <import resource="beans_2.xml"/>
    <bean id="userBean" name="userBean"
          class="springtest.UserBean"
          abstract="false"
          singleton="true"
          lazy-init="default"
          autowire="default"
          dependency-check="default" >
            <property name="name">
                <ref  bean="str1"/>
            property>
    bean>
beans>

加载就用上的 -》单配置文件加载

2).动态替换类方法（cglib）
配置文件中替换方法(替换方法 getName ) lib中加入 cglib.jar

xml version="1.0" encoding="UTF-8"?>
DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <import resource="beans_2.xml"/>
    <bean id="userBean" name="userBean"
          class="springtest.UserBean"
          abstract="false"
          singleton="true"
          lazy-init="default"
          autowire="default"
          dependency-check="default" >
              <replaced-method name="getName" replacer="rm">
                  <arg-type>Stringarg-type>
              replaced-method>
            <property name="name">
                <ref  bean="str1"/>
            property>
    bean>

    <bean id="rm" class="springtest.ReplacedMethod"/>
beans>

springtest.ReplacedMethod类

package springtest;

import java.lang.reflect.Method;

import org.springframework.beans.factory.support.MethodReplacer;

public class ReplacedMethod implements MethodReplacer {

    public Object reimplement(Object arg0, Method arg1, Object[] arg2) throws Throwable {
        return "刘凯毅";
    }
}

结果：不管你怎么setName getName出来的都是-》 “刘凯毅”

3.自定义作用域bean 需要jdk1.5

4.定制bean特性
1）初始化回调方法init()
和继承org.springframework.beans.factory.InitializingBean 实现接口方法 void afterPropertiesSet() throws Exception; 一样
2）

G_G 2007-12-21 16:33 发表评论

为我学习 Spring AOP 准备（Proxy）

G_G — Tue, 09 Oct 2007 03:13:00 GMT

为我准备学习和理解spring
特留下代码笔记：
参考：
http://dev.csdn.net/author/labile/e70c97cb7f504d35b7b5350e7810cc5a.html
代码感想：
没个方法都或多或少需要环境参数(如: jdbc的conn ,hbn的session...等等 )，方法结束后又要关闭。
何不用proxy代理并用配置文件的方法来关,开session 等
如：以下是我的想法并不是实际可用

配置：
<class name="HelloWorldImpl">
<function name="set*" />

<function name="getName">
    <proxyBegin artt="name" value="liukaiyi"/>
        //使用Proxy来赋值 name那在实现代码中就可以不用去关注象 session 等属性的开关了
        //proxy中配置下，在实现类中就使用就可以了
    <proxyBegin ref="HelloWorldHandler.doBefter" args="null"/>
    <proxyEnd ref="HelloWorldHandler.doAfter" args="null"/>
function>

<function = name="sayHelloWorld">
    ="HelloWorldHandler.doAfter" args="null"/>
function>
class>

代码：
HelloWorld hw = (HelloWorld)Factory.getBean("HelloWorldImpl");
hw.getName();

结果是：
before method invoke!
刘凯毅
after method invoke!

在此我只是想象，spring 还没有看，但我认为spring 这个著名的框架应该在这方面有很好的实现。

实际代码：希望spring可以向我上面的方法配置好用来取代下面的实际代码 ^_^

package test.proxy;

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

import junit.framework.TestCase;

public class TestProxy extends TestCase {

    protected void setUp() throws Exception {
        super.setUp();
    }

    public void testProxy(){
             HelloWorld hw = new HelloWorldImpl();
                       InvocationHandler handler = new HelloWorldHandler(hw);
                       HelloWorld proxy = (HelloWorld) Proxy.newProxyInstance(
                                     hw.getClass().getClassLoader(),
                                     hw.getClass().getInterfaces(),
                                     handler);
                       proxy.sayHelloWorld();

                       System.out.println();
                       proxy.setName("liukaiyi");
                       proxy.getName();
    }

}

interface HelloWorld {
    void sayHelloWorld() ;
    void getName();
    void setName(String name);
}

class HelloWorldImpl implements HelloWorld {
    private String name = "";
    public void setName(String name) {
        this.name = name;
    }

    public void sayHelloWorld() {
        System.out.println("Hello World!");
    }

    public void getName() {
        System.out.println(this.name);
    }
}

class HelloWorldHandler implements InvocationHandler {
            //要代理的原始对象
            private Object objOriginal;
            /**
             * 构造函数。
             * @param obj 要代理的原始对象。
             */
            public HelloWorldHandler(Object obj) {
                   this.objOriginal = obj ;
            }
            public Object invoke(Object proxy, Method method, Object[] args)
                          throws Throwable {
                   Object result = null ;
                   String meName = method.getName();
                   if(meName.indexOf("set")>-1 ){
                       return method.invoke(this.objOriginal ,args);
                   }
                   if( meName.equals("getName") ){
                    //方法调用之前
                           doBefore(); //仿佛是AOP的影子，呵呵
                   }
                     //调用原始对象的方法
                           result = method.invoke(this.objOriginal ,args);
                     //方法调用之后
                           doAfter();

                   return result ;
            }
            private void doBefore() {
                   System.out.println("before method invoke!");
            }
            private void doAfter() {
                   System.out.println("after method invoke!");
            }
     }

结果：
Hello World!
after method invoke!

before method invoke!
刘凯毅
after method invoke!

G_G 2007-10-09 11:13 发表评论