Spring+hibernate+struts

1、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事務處理
聲明式，
編程式.

 

2、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>

 

3、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>