Spring+hibernate+struts

一、Spring

主要功能：解耦和（对象之间可配置，依赖注入的）

1.概念：

容器：容器可以装载对象，实例化对象，配置对象之间的依赖关系。

IOC/DI
IOC：Inversion of Control(控制反转)，是指程序之间的依赖关系由依赖具体实现(如DISKUSB，UUSB)，变为依赖抽象接口(USB). 
        一句话：依赖抽象非具体。
DI：Dependency Injection(依赖注入)，是指程序之间的依赖关系由容器动态注入，而非硬编码实现。
        Spring里的所有类都是JavaBean，Bean就像项链的柱子，配置文件就像线一样把所有珠子串起来。

AOP：Aspect Oriented programming(面向方面编程)，是指将程序中的某一方面独立出来，单独设计（如事务，日志，权限等）。

2.Spring简介
(1)对企业级开发提供一站式服务(集成hibernate,spring mvc等)；
(2)IOC:Spring的核心思想和实现，大部分功能都基于此；
(3)AOP：在Spring中提供了三种对AOP技术的实现；
(4)对持久称的支持：封装了JDBC的操作；
　　　　　　　　　  集成了流行的技术框架(Hibernate,JDO,Toplink,iBATTS);
(5)对web层的支持：
　　　　　　　　Spring MVC;
　　　　　　　　对其它框架的支持(Struts,WebWork)
(6)对其它框架和技术的集成：
　　RMI和WebService
　　EJB
　　JMS
　　JavaMail
　　定时任务和调度

3.使用Spring
(1)添加jar包：spring.jar,commons-logging.jar;
(2)创建配置文件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="hw" class="com.lb.action.Test2">
        <property name="name" value="zhangsan" />
    </bean>
</beans>

 

public class Test2 {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void HelloWord(){
        System.out.println(name);
    }
    public static void main(String[] args) {
        //(3)获得Bean工厂；
        Resource rs = new ClassPathResource("beans.xml");
        BeanFactory bf = new XmlBeanFactory(rs);
        //(4)获得对象。
        Test2 t2 = (Test2) bf.getBean("hw");
        //(5)调用方法
        t2.HelloWord();
        /*Test2 t2 = new Test2();
        t2.setName("zhangsan2");
        t2.HelloWord();*/
    }
}

 依赖注入的例子：
interface usb

package com.lb.action;

public interface Usb {
    public void read();
    public void write();
}

UUSB实现类

package com.lb.action;

public class UUSB implements Usb{
    public void read(){
        System.out.println("read from UUSB.....");
    }
    public void write(){
        System.out.println("write to UUSB.....");
    }
}

DiskUSB实现类

package com.lb.action;

public class DiskUSB implements Usb{
    public void read(){
        System.out.println("read from DiskUSB....");
    }
    public void write(){
        System.out.println("write to DiskUSB....");
    }
}

Computer依赖类,依赖uUSB或者diskUSB

package com.lb.action;

public class Computer{
    private Usb usb;
    public void setUsb(Usb usb) {
        this.usb = usb;
    }
    public void test(){
        usb.read();
        usb.write();
    }
}

主函数：

package com.lb.action;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class Test2 {
    public static void main(String[] args) {
        Resource rs = new ClassPathResource("beans.xml");
        BeanFactory bf = new XmlBeanFactory(rs);
        Computer computer = (Computer) bf.getBean("computer");
        computer.test();
    }
}

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="hw" class="com.lb.action.Test2">
        <property name="name" value="zhangsan" />
    </bean>
    <bean id="uUSB" class="com.lb.action.UUSB" />
    <bean id="DiskUSB" class="com.lb.action.DiskUSB" />
    <bean id="computer" class="com.lb.action.Computer">
        <!-- 属性usb依赖id为DiskUSB的bean -->
        <property name="usb" ref="DiskUSB"></property>
    </bean>
</beans>

 4.使用IOC容器管理Bean
(1)IOC容器简介
　　*Java里的类在Spring里都被成为Bean;
　　*容器是用来读取Bean的定义，管理对象的初始化、生产以及对象之间的依赖关系。

　　在Spring当中的IOC容器是由BeanFactory和ApplicationContext这两个接口来实现的。

　　BeanFactory的常用方法：Object getBean(String name) 根据Bean标识(id)获得Bean实例。

(2)Bean的定义标识和别名

<bean id="hw" class="com.lb.action.Test2">
        <property name="name" value="zhangsan" />
</bean>

 

(3)Bean的实例化
两种方法：
　　BeanFactory

Resource rs = new ClassPathResource("beans.xml");
BeanFactory bf = new XmlBeanFactory(rs);
Computer computer = (Computer) bf.getBean("computer");

　　ApplicationContext(很常用)

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Computer computer = (Computer) context.getBean("computer");

 

(4)Bean的scope
　　Singleton：在Spring中，从容器中获得的实例都是单例的；
　　Prototype：如果每次都想获得一个新的实例，则可以把bean的scope属性设置为scope="Prototype";
　　Request
　　Session
　　GlobalSession

5.Spring AOP Annotaion实现(AOP思想本质就是拦截)
参考：http://blog.csdn.net/wangpeng047/article/details/8556800 
(1)@AspectJ简介
　　使用了Java5的注解，可以将切面声明为普通的Java类。

(2)启用@AspectJ支持
　　在beans.xml配置文件里加<aop:aspectj-autoproxy/>
　　可直接复制文档里的配置文件。

(3)声明一个切面
　　在类前面加@Aspect.

(4)声明一个切入点(pointcut)
　　a.切入点简介
　　b.切入点匹配表达式
　　c.execution pointcut表达式
　　d.切入点声明:加在方法名前如：@Before("execution(* com.lb.test.User.*(..))")

(5)声明通知(advice)
　　a.Before advice  如：@Before("execution(* com.lb.test.User.*(..))")
　　b.After advice
　　c.Around advice
　　d.Throwing advice

schema方式的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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<!-- <bean/> definitions here -->

    <bean id="UserDaoImp" class="com.jrgc.test.UserDaoImp" />
    <bean id="logBeforea" class="com.jrgc.test.TestAnnotationAspect" />
    <aop:aspectj-autoproxy/>
</beans>

切面、切入点声明：

package com.jrgc.test;

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

@Aspect
public class TestAnnotationAspect {
    @Pointcut("execution(* com.jrgc.test.UserDao.*(..))")
    public void pointCutMethod() {  
        System.out.println("pointcut...........");
    }
    
      
    @Before("execution(* com.jrgc.test.UserDao.*(..))")
    public void logBefore(){
        System.out.println("Annotation -> before log.......");
    }
}

 

6.Spring AOP API实现(Spring2.0以后不推荐用此方式，而推荐用XML配置或者anotation注解方式)

 (1)代理类ProxyFactoryBean
　　在Spring里创建一个AOP代理的基本方法是使用org.springframwork.aop.framwork.ProxyFactoryBean|
　　这个类对应用的切入点和通知提供了完整的控制能力。
　　-重要属性：
　　proxyInterface:被代理的接口；
　　target：被代理的实例；
　　interceptorNames：advice实例
(2)Advices
　　概念：Advice实现了Aspect的真正逻辑，具体来说就是Java里的一个类或者一个方法。
　　分类：由于切入至target的时机不同，Spring提供了以下几种不同的Advices
　　　　-Before advice：比如转账前检查权限；
　　　　-After advice：转账后记录日志；
　　　　-Around advice
　　　　-Throw advice
　　Before advice
　　-Before advice会在目标对象的方法执行之前被调用；
　　-需要实现的接口是：MethodBeforeAdvice，定义如下：
　　　　Public Interface MethodBeforeAdvice extends BeforeAdvice{
　　　　　　void before(Method m,Object[] args,Object target)  throws
　　　　　　Throwable;

　　　　}
　　　　m:被执行的方法；
　　　　args:方法的参数列表；
　　　　target:目标对象。

7.Spring AOP 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"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd   
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd   
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd   
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd"> 
    <!-- bean都是实例类 -->
    <bean id="logBeforeAdvice" class="com.jrgc.test.LogBeforeAdvice" />
    <bean id="logAfterAdvice" class="com.jrgc.test.LogAfterAdvice" />
    <bean id="logAroundAdvice" class="com.jrgc.test.LogAroundAdvice" />
    <bean id="logThrowAdvice" class="com.jrgc.test.LogThrowAdvice" />
    <bean id="UserDaoImp" class="com.jrgc.test.UserDaoImp">
        <property name="name" value="zhangsan" />
    </bean>
    
    <!-- execution里的都是接口 -->
    <aop:config>
        <aop:aspect ref="logBeforeAdvice">
            <aop:pointcut expression=" execution(* com.jrgc.test.UserDao.*(..)) " id="user" />
            <aop:before method="logBefore" pointcut-ref="user" />
        </aop:aspect>
        <aop:aspect ref="logAfterAdvice">
            <aop:pointcut expression=" execution(* com.jrgc.test.UserDao.*(..)) " id="user"/>
            <aop:after method="logAfter" pointcut-ref="user"/>
        </aop:aspect>
        <aop:aspect ref="logAroundAdvice">
            <aop:pointcut expression=" execution(* com.jrgc.test.UserDao.*(..)) " id="user" />
            <aop:around method="logAround" pointcut-ref="user"/>
        </aop:aspect>
        <aop:aspect ref="logThrowAdvice">
            <aop:pointcut expression=" execution(* com.jrgc.test.UserDao.*(..)) " id="user" />
            <aop:after-throwing method="logThrow" pointcut-ref="user" />
        </aop:aspect>
    </aop:config>
</beans>

主函数：

package com.jrgc.test;

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


public class Test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //采用接口类型UserDao,因为Spring里是依赖一个接口而不是依赖一个类
        UserDao user = (UserDao) context.getBean("UserDaoImp");
        user.delete();
        
    }
}

接口：

package com.jrgc.test;

public interface UserDao {
    public void delete();
}

接口实现类：

package com.jrgc.test;

public class UserDaoImp implements UserDao{
    private String name;
    @Override
    public void delete() {
        // TODO Auto-generated method stub
        
        /**
         * 做异常测试
        String str = null;
        str.length();*/
        System.out.println("delete.......");
    }
}

beforeAdvice:

package com.jrgc.test;

public class LogBeforeAdvice {
    public void logBefore(){
        System.out.println("before log........");
    }
}

aroundAdvice:

package com.jrgc.test;

import org.aspectj.lang.ProceedingJoinPoint;

public class LogAroundAdvice {
    public void logAround(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("around before log.....");
        pjp.proceed();
        System.out.println("around after log.....");
    }
}

其它Advice省略，因为类似。

8.Spring 事务处理

（1）事务的抽象
-PlatformTransactionManager接口；
-TransactionDefinition接口；
-TransactionStatus接口.

(2)声明式事务处理
-为不同的bean配置不同的事务语义（AOP XML）；
-使用@Transaction （AOP注解）

(3)编程式事务处理
-使用TransactionTemplate;
-使用PlatformTransactionManager.

9.Spring JDBC

　　在Java的持久层方案中有JDBC和ORM两种实现方式，Spring也提供了对持久层JDBC的封装。

(1)JDBC核心类
JdbcTemplate类，
NamedParamterJdbcTemplate类，
DataSource接口.

(2)基本操作
执行SQL语句，execute()
执行查询，query()
更新数据库

(3)JDBC事务处理
声明式，
编程式.

 

二、Hibernate

参考：
　　各种操作方法：http://blog.sina.com.cn/s/blog_4586764e0100o8gg.html

Myeclipse添加Hibernite:
1.

2.生成hibernate.cfg.xml主配置文件

3.添加连接的数据库信息

4.生成主Hibernate的工具类

5.将实体类的映射文件User.hbm.xml添加到主配置文件hibernate.xml里

hibernate.cfg.xml配置文件如下：

<?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">
<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

<session-factory>
    <property name="dialect">
        org.hibernate.dialect.MySQLDialect
    </property>
    <property name="connection.url">
        jdbc:mysql://localhost:3306/test
    </property>
    <property name="connection.username">root</property>
    <property name="connection.driver_class">
        com.mysql.jdbc.Driver
    </property>
    <property name="myeclipse.connection.profile">kaoqin</property>
    <mapping resource="com/jrgc/entity/User.hbm.xml" />

</session-factory>

</hibernate-configuration>

User.hbm.xml配置文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<hibernate-mapping>
    <class table="User" name="com.jrgc.entity.User">
        <id name="id">
            <generator class="native"></generator>
        </id>
        <property name="username"/>
        <property name="password"/>
    </class>
</hibernate-mapping>

 

三、Struts2

1.action的type属性redirect和redirect-action的一点区别是：redirect直接跳转，可以正常传递参数,而redirect-action不可以.

    <action name="UserAdd" class="com.jrgc.actions.UserAdd" method="userAdd">
        <result name="success" type="redirect">UserList.action?operType=${operType}</result>
    </action>

    <action name="UserAdd" class="com.jrgc.actions.UserAdd" method="userAdd">
        <result name="success" type="redirect-action">
            <param name="actionName">UserList.action</param>
        <param name="operType">${operType}</param>
        </result>
    </action>