JAVA SSH学习 - Java、Struts、Hibernate、Spring学习笔记

Java、Struts、Hibernate、Spring学习笔记

Jul 27

Hibernate一级缓存和二级缓存

ljh , 10:16 , JAVA SSH学习 , 评论(0) , 引用(0) , 阅读(16)

一级缓存
Hibernate框架一级缓存的特点：
1.它是hibernate自带的，不用我们手动配置。
2.它是以K-V对的方式存储数据，以KEY去获得PO对象。
3.只在同一个中session共享。
由于是hibernate自身就带有的，所以使用时不需要配置XML的工作，只要知道在同一个session中的存在相应的对象，那么它们都是共享的就可以了。
值得注意的是：
1.通过在做查询的时候，有几个查询方法支持一级Hibernate缓存，它们分别是：load(),get(),iterate(),其中要注意的是iterate方法只对实体对象查询才支持一级缓存，如果使用iterate来查询对象里面的相关属性，则查询的时候不支持一级缓存。
2.在管理一级缓存的时候可以使用，clear()和evict(object)两个方法，clear是清空全部，evict是清除指定的缓存对象。要好好的使用这两个方法，特别是在缓存数据量大的情况下。

二级缓存
Hibernate框架二级缓存的特点：
1.同样是K-V对的方式存储数据，以ID作为KEY。
2.它的共享范围是SessionFactory。
3.它不是自带的，使用时需要导入第三方实现架包，并做相应配置。常用的有EHcache（官方推荐）,JBossCache,OScache等等。
二级缓存和session级别的缓存一样都只对实体对象做缓存，不对属性级别的查询做缓存。

EHcache的简单使用：
先配置一个叫做：ehcache.xml文件

Xml代码

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
<diskStore path="d:/cache" />
<defaultCache maxElementsInMemory="1000" eternal="false"
overflowToDisk="true" timeToIdleSeconds="180" timeToLiveSeconds="300"
diskPersistent="false" diskExpiryThreadIntervalSeconds="120" />
<cache name="longTime" maxElementsInMemory="100" eternal="false"
overflowToDisk="true" timeToIdleSeconds="1800"
timeToLiveSeconds="3000" diskPersistent="false"
diskExpiryThreadIntervalSeconds="120" />
</ehcache>

diskStore 作用是如果要缓存到硬盘上，这里填写缓存到硬盘的路径。
maxElementsInMemory 作用是最大缓存连接数，也就是说只能在缓存中保存这里设置的数量。
overflowToDisk 当设置为true的时候，如果内存不足时就把缓存保存到硬盘。
timeToIdleSeconds 最大空闲时间，超过了这个时间就算超时了。
timeToLiveSeconds 最大生存时间。
defaultCache 是默认调用的缓存模版。
cache 是自定义其他缓存模版，这样的好处在于可以配置多个缓存模版，然后在hibernate-mapping中绑定到某个class。
例如：

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 name="com.lovo.po.UserPO" table="userinfo" optimistic-lock="version">
<cache region="longTime" usage="read-write"/>
<id name="id" column="uid" type="int">
<generator class="increment"></generator>
</id>
<version name="verson" column="version" type="int" />
<property name="username" column="name" type="string"></property>
...
</class>
</hibernate-mapping>

接下来就在hibernate.cfg.xml文件中标明要使用二级缓存

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">
<hibernate-configuration>
...
<property name="hibernate.cache.EhCacheProvider">true</property>
<property name="cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property>
<property name="hibernate.cache.use_query_cache">true</property>
...
</session-factory>
</hibernate-configuration>

Tags: ehcache , hibernate

Jul 27

tomcat集群和负载均衡的实现（session同步）

ljh , 10:04 , JAVA SSH学习 , 评论(0) , 引用(0) , 阅读(13)

(一)环境说明
(1)服务器有4台，一台安装apache,三台安装tomcat
(2)apache2.0.55、tomcat5.5.15、jk2.0.4、jdk1.5.6或jdk1.4.2
(3)ip配置,一台安装apache的ip为192.168.0.88,三台安装tomcat的服务器ip分别为192.168.0.1/2/4
(二)安装过程
(1)在三台要安装tomcat的服务器上先安装jdk
(2)配置jdk的安装路径,在环境变量path中加入jdk的bin路径,新建环境变量JAVA_HOME指向jdk的安装路径
(3)在三台要安装tomcat的服务器上分别安装tomcat,调试三个tomcat到能够正常启动
(4)tomcat的默认WEB服务端口是8080,默认的模式是单独服务,我的三个tomcat的WEB服务端口修改为7080/8888/9999
修改位置为tomcat的安装目录下的conf/server.xml
修改前的配置为
    <Connector port="8080" maxHttpHeaderSize="8192"
               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="100"
               connectionTimeout="20000" disableUploadTimeout="true" />
修改后的配置为
    <Connector port="7080" maxHttpHeaderSize="8192"
               maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
               enableLookups="false" redirectPort="8443" acceptCount="100"
               connectionTimeout="20000" disableUploadTimeout="true" />
依次修改每个tomcat的监听端口(7080/8888/9999)

(5)分别测试每个tomcat的启动是否正常
http://192.168.0.1:7080
http://192.168.0.2:8888
http://192.168.0.4:9999
(三)负载均衡配置过程
(1)在那台要安装apache的服务器上安装apache2.0.55,我的安装路径为默认C:\Program Files\Apache Group\Apache2
(2)安装后测试apache能否正常启动，调试到能够正常启动http://192.168.0.88
(3)下载jk2.0.4后解压缩文件
(4)将解压缩后的目录中的modules目录中的mod_jk2.so文件复制到apache的安装目录下的modules目录中,我的为C:\Program Files\Apache Group\Apache2\modules
(5)修改apache的安装目录中的conf目录的配置文件httpd.conf，在文件中加LoadModule模块配置信息的最后加上一句LoadModule jk2_module modules/mod_jk2.so
(6)分别修改三个tomcat的配置文件conf/server.xml，修改内容如下
修改前

<Engine name="Catalina" defaultHost="localhost">
修改后

<Engine name="Standalone" defaultHost="localhost" jvmRoute="tomcat1">


    
将其中的jvmRoute="jvm1"分别修改为jvmRoute="tomcat1"和jvmRoute="tomcat2"和jvmRoute="tomcat3"

(7)然后重启三个tomcat，调试能够正常启动。
(8)在apache的安装目录中的conf目录下创建文件workers2.propertie，写入文件内容如下

# fine the communication channel
[channel.socket:192.168.0.1:8009]
info=Ajp13 forwarding over socket
#配置第一个服务器
tomcatId=tomcat1 #要和tomcat的配置文件server.xml中的jvmRoute="tomcat1"名称一致
debug=0
lb_factor=1 #负载平衡因子，数字越大请求被分配的几率越高

# Define the communication channel
[channel.socket:192.168.0.2:8009]
info=Ajp13 forwarding over socket
tomcatId=tomcat2
debug=0
lb_factor=1

# Define the communication channel
[channel.socket:192.168.0.4:8009]
info=Ajp13 forwarding over socket
tomcatId=tomcat3
debug=0
lb_factor=1

[status:]
info=Status worker, displays runtime information.

[uri:/jkstatus.jsp]
info=Display status information and checks the config file for changes.
group=status:

[uri:/*]
info=Map the whole webapp
debug=0
(9)在三个tomcat的安装目录中的webapps建立相同的应用,我和应用目录名为TomcatDemo,在三个应用目录中建立相同 WEB-INF目录和页面index.jsp,index.jsp的页面内容如下
<%@ page contentType="text/html; charset=GBK" %>
<%@ page import="java.util.*" %>
<html><head><title>Cluster App Test</title></head>
<body>
Server Info:
<%
out.println(request.getLocalAddr() + " : " + request.getLocalPort()+"<br>");%>
<%
out.println("<br> ID " + session.getId()+"<br>");

// 如果有新的 Session 属性设置
String dataName = request.getParameter("dataName");
if (dataName != null && dataName.length() > 0) {
String dataValue = request.getParameter("dataValue");
session.setAttribute(dataName, dataValue);
}

out.print("<b>Session 列表</b>");

Enumeration e = session.getAttributeNames();
while (e.hasMoreElements()) {
     String name = (String)e.nextElement();
     String value = session.getAttribute(name).toString();
     out.println( name + " = " + value+"<br>");
         System.out.println( name + " = " + value);
   }
%>
<form action="index.jsp" method="POST">
    名称:<input type=text size=20 name="dataName">
     <br>
    值:<input type=text size=20 name="dataValue">
     <br>
    <input type=submit>
   </form>
</body>
</html>
(10)重启apache服务器和三个tomcat服务器,到此负载均衡已配置完成。测试负载均衡先测试apache,访问http://192.168.0.88/jkstatus.jsp
能否正常访问，并查询其中的内容，有三个tomcat的相关配置信息和负载说明,访问http://192.168.0.88/TomcatDemo/index.jsp看能够运行,
能运行，则已建立负载均衡。
(四)tomcat集群配置
(1)负载均衡配置的条件下配置tomcat集群
(2)分别修改三个tomcat的配置文件conf/server.xml,修改内容如下
修改前
        <!--
        <Cluster className="org.apache.catalina.cluster.tcp.SimpleTcpCluster"
                 managerClassName="org.apache.catalina.cluster.session.DeltaManager"
                 expireSessionsOnShutdown="false"
                 useDirtyFlag="true"
                 notifyListenersOnReplication="true">

<Valve className="org.apache.catalina.cluster.tcp.ReplicationValve"
                   filter=".*\.gif;.*\.js;.*\.jpg;.*\.png;.*\.htm;.*\.html;.*\.css;.*\.txt;"/>

            <Deployer className="org.apache.catalina.cluster.deploy.FarmWarDeployer"
                      tempDir="/tmp/war-temp/"
                      deployDir="/tmp/war-deploy/"
                      watchDir="/tmp/war-listen/"
                      watchEnabled="false"/>

            <ClusterListener className="org.apache.catalina.cluster.session.ClusterSessionListener"/>
        </Cluster>
       
将集群配置选项的注释放开即可，如上。
(3)重启三个tomcat。到此tomcat的集群已配置完成。

(五)应用配置
对于要进行负载和集群的的tomcat目录下的webapps中的应用中的WEB-INF中的web.xml文件要添加如下一句配置
<distributable/>
配置前
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">
<display-name>TomcatDemo</display-name>
</web-app>
配置后
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">
<display-name>TomcatDemo</display-name>
<distributable/>
</web-app>

tomcat集群和负载均衡的实现（session同步）补充
因为tomcat的session同步功能需要用到组播，windows默认情况下是开通组播服务的，但是linux默认情况下并没有开通，可以通过指令打开route add -net 224.0.0.0 netmask 240.0.0.0 dev eth0，如果需要服务器启动时即开通组播需在/etc/sysconfig/static-routes文件内加入eht0 net 224.0.0.0 netmask 240.0.0.0。具体组播概念请查阅CCNP相关内容。

Jul 27

JAVA reflect 反射机制学习笔记

ljh , 09:57 , JAVA SSH学习 , 评论(0) , 引用(0) , 阅读(18)

JAVA反射机制主要提供了以下功能：
1.在运行时判断任意一个对象所属的类
2.在运行时构造任意一个类的对象
3.在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）
4.在运行时调用任意一个对象的方法（*****注意：前提都是在运行时，而不是在编译时）

Java 反射相关的API简介：
位于java。lang。reflect包中
--Class类：代表一个类
--Filed类：代表类的成员变量
--Method类：代表类的方法
--Constructor类：代表类的构造方法
--Array类：提供了动态创建数组，以及访问数组的元素的静态方法。该类中的所有方法都是静态方法

1. 得到某个对象的属性

Java代码

public Object getProperty(Object owner, String fieldName) throws Exception {
Class ownerClass = owner.getClass();
Field field = ownerClass.getField(fieldName);
Object property = field.get(owner);
return property;
}

 public Object getProperty(Object owner, String fieldName) throws Exception {       Class ownerClass = owner.getClass();          Field field = ownerClass.getField(fieldName);        Object property = field.get(owner);          return property;   }

Class ownerClass = owner.getClass()：得到该对象的Class。

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。
2. 得到某个类的静态属性

Java代码

public Object getStaticProperty(String className, String fieldName)
throws Exception {
Class ownerClass = Class.forName(className);
Field field = ownerClass.getField(fieldName);
Object property = field.get(ownerClass);
return property;
}

   public Object getStaticProperty(String className, String fieldName)                throws Exception {      Class ownerClass = Class.forName(className);         Field field = ownerClass.getField(fieldName);           Object property = field.get(ownerClass);          return property;   }

Class ownerClass = Class.forName(className) ：首先得到这个类的Class。

Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。

Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。
3. 执行某对象的方法

Java代码

public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
Class ownerClass = owner.getClass();
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
Method method = ownerClass.getMethod(methodName, argsClass);
return method.invoke(owner, args);
}

 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {        Class ownerClass = owner.getClass();           Class[] argsClass = new Class[args.length];           for (int i = 0, j = args.length; i < j; i++) {           argsClass[i] = args[i].getClass();        }          Method method = ownerClass.getMethod(methodName, argsClass);         return method.invoke(owner, args);  }

Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。
Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。

method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。
4. 执行某个类的静态方法

Java代码

public Object invokeStaticMethod(String className, String methodName,
Object[] args) throws Exception {
Class ownerClass = Class.forName(className);
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
Method method = ownerClass.getMethod(methodName, argsClass);
return method.invoke(null, args);
}

 public Object invokeStaticMethod(String className, String methodName,              Object[] args) throws Exception {        Class ownerClass = Class.forName(className);           Class[] argsClass = new Class[args.length];         for (int i = 0, j = args.length; i < j; i++) {            argsClass[i] = args[i].getClass();        }       Method method = ownerClass.getMethod(methodName, argsClass);         return method.invoke(null, args);   }

基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。
5. 新建实例

Java代码

public Object newInstance(String className, Object[] args) throws Exception {
Class newoneClass = Class.forName(className);
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}
Constructor cons = newoneClass.getConstructor(argsClass);
return cons.newInstance(args);
}

  public Object newInstance(String className, Object[] args) throws Exception {        Class newoneClass = Class.forName(className);           Class[] argsClass = new Class[args.length];           for (int i = 0, j = args.length; i < j; i++) {            argsClass[i] = args[i].getClass();        }          Constructor cons = newoneClass.getConstructor(argsClass);        return cons.newInstance(args);      }

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。

Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。
for循环：得到参数的Class数组。

Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。

cons.newInstance(args)：新建实例。
6. 判断是否为某个类的实例

Java代码

public boolean isInstance(Object obj, Class cls) {
return cls.isInstance(obj);
}

  public boolean isInstance(Object obj, Class cls) {       return cls.isInstance(obj);   }

7. 得到数组中的某个元素

Java代码

public Object getByArray(Object array, int index) {
return Array.get(array,index);
}

  public Object getByArray(Object array, int index) {       return Array.get(array,index);   }

下面摘录一个应用的例子

Java代码

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TestRef{
public static void main(String[] args){
TestBean test = new TestBean();
Method[] methods = test.getClass().getMethods();
test.setAbc("---");
for(int i=0;i<methods.length;i++){
if(methods[i].getName().equalsIgnoreCase("getabc")){
try {
System.out.println(methods[i].invoke(test));
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
}

import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method;  public class TestRef{       public static void main(String[] args){             TestBean test = new TestBean();             Method[] methods = test.getClass().getMethods();             test.setAbc("---");             for(int i=0;i<methods.length;i++){                 if(methods[i].getName().equalsIgnoreCase("getabc")){                     try {                         System.out.println(methods[i].invoke(test));                     } catch (IllegalArgumentException e) {                         e.printStackTrace();                     } catch (IllegalAccessException e) {                         e.printStackTrace();                     } catch (InvocationTargetException e) {                         e.printStackTrace();                     }                 }             }     } }

可以扩展到action里面，如果一个action里面有多个方法，我们不用用if(){}else{}判断了，反射的确扩展性，适应性比较好呵呵

Tags: reflect , 反射

Jul 27

SSH中 struts hibernate spring 各框架各起什么作用

ljh , 09:54 , JAVA SSH学习 , 评论(0) , 引用(0) , 阅读(15)

简单的说：

struts 控制用的

hibernate 操作数据库的

spring 用解耦的

详细的说：

STRUTS 在 SSH 框架中起控制的作用 , 其核心是 Controller, 即 ActionServlet, 而 ActionServlet 的核心就是 Struts-confi g.xml. 主要控制逻辑关系的处理 .

hibernate 是数据持久化层 , 是一种新的对象、关系的映射工具 , 提供了从 Java 类到数据表的映射，也提供了数据查询和恢复等机制 , 大大减少数据访问的复杂度。把对数据库的直接操作 , 转换为对持久对象的操作 .

SPRING 是一个轻量级的控制反转 (IoC) 和面向切面 (AOP) 的容器框架 , 面向接口的编程 , 由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。这也就是所谓 “ 控制反转 ” 的概念所在：（依赖）控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。依赖注入，即组件之间的依赖关系由容器在运行期决定，形象的来说，即由容器动态的将某种依赖关系注入到组件之中
起到的主要作用是解耦

Struts 、 spring 、 Hibernate 在各层的作用

1 ） struts 负责 web 层 .

ActionFormBean 接收网页中表单提交的数据，然后通过 Action 进行处理，再 Forward 到对应的网页。

在 struts-config.xml 中定义 <action-mapping>, ActionServlet 会加载。

2 ） spring 负责业务层管理，即 Service （或 Manager).

1 ． service 为 action 提供统计的调用接口，封装持久层的 DAO.

2 ．可以写一些自己的业务方法。

3 ．统一的 javabean 管理方法

4 ．声明式事务管理

5. 集成 Hiberante

3 ） Hiberante ，负责持久化层，完成数据库的 crud 操作

hibernate 为持久层，提供 OR/Mapping 。

它有一组 .hbm.xml 文件和 POJO, 是跟数据库中的表相对应的。然后定义 DAO ，这些是跟数据库打交道的类，它们会使用 PO 。

在 struts+spring+hibernate 的系统中，

对象的调用流程是： jsp-> Action － > Service ->DAO ->Hibernate 。

数据的流向是 ActionFormBean 接受用户的数据， Action 将数据从 ActionFromBean 中取出，封装成 VO 或 PO,

再调用业务层的 Bean 类，完成各种业务处理后再 forward 。而业务层 Bean 收到这个 PO 对象之后，会调用 DAO 接口方法，进行持久化操作。

Jul 27

为什么SSH框架中要使用Spring

ljh , 09:53 , JAVA SSH学习 , 评论(0) , 引用(0) , 阅读(12)

    在SSH框假中spring充当了管理容器的角色。我们都知道Hibernate用来做持久层，因为它将JDBC做了一个良好的封装，程序员在与数据库进行交互时可以不用书写大量的SQL语句。Struts是用来做应用层的，他它负责调用业务逻辑serivce层。所以SSH框架的流程大致是：Jsp页面----Struts------Service（业务逻辑处理类）---Hibernate（左到右）
struts负责控制Service（业务逻辑处理类），从而控制了Service的生命周期，这样层与层之间的依赖很强，属于耦合。这时，使用spring框架就起到了控制Action对象（Strus中的）和Service类的作用，两者之间的关系就松散了，Spring的Ioc机制（控制反转和依赖注入）正是用在此处。
     Spring的Ioc（控制反转和依赖注入）
     控制反转：就是由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控
     依赖注入：组件之间的依赖关系由容器在运行期决定，由容器动态的将某种依赖关系注入到组件之中。
   从上面我们不难看出：从头到尾Action仅仅是充当了Service的控制工具，这些具体的业务方法是怎样实现的，他根本就不会管，也不会问，他只要知道这些业务实现类所提供的方法接口就可以了。而在以往单独使用Struts框架的时候，所有的业务方法类的生命周期，甚至是一些业务流程都是由Action来控制的。层与层之间耦合性太紧密了，既降低了数据访问的效率又使业务逻辑看起来很复杂，代码量也很多。，Spring容器控制所有Action对象和业务逻辑类的生命周期，由于上层不再控制下层的生命周期，层与层之间实现了完全脱耦，使程序运行起来效率更高，维护起来也方便。
使用Spring的第二个好处（AOP应用）：
    事务的处理：
   在以往的JDBCTemplate中事务提交成功，异常处理都是通过Try/Catch 来完成，而在Spring中。Spring容器集成了TransactionTemplate，她封装了所有对事务处理的功能，包括异常时事务回滚，操作成功时数据提交等复杂业务功能。这都是由Spring容器来管理，大大减少了程序员的代码量，也对事务有了很好的管理控制。Hibernate中也有对事务的管理，hibernate中事务管理是通过SessionFactory创建和维护Session来完成。而Spring对SessionFactory配置也进行了整合，不需要在通过hibernate.cfg.xml来对SessionaFactory进行设定。这样的话就可以很好的利用Sping对事务管理强大功能。避免了每次对数据操作都要现获得Session实例来启动事务/提交/回滚事务还有繁琐的Try/Catch操作。这些也就是Spring中的AOP（面向切面编程）机制很好的应用。一方面使开发业务逻辑更清晰、专业分工更加容易进行。另一方面就是应用Spirng AOP隔离降低了程序的耦合性使我们可以在不同的应用中将各个切面结合起来使用大大提高了代码重用度。

分页： 1/6

1 2 3 4 5 6

[ 显示模式：摘要 | 列表 ]

Hibernate一级缓存和二级缓存

tomcat集群和负载均衡的实现（session同步）

JAVA reflect 反射机制学习笔记

SSH中 struts hibernate spring 各框架各起什么作用

为什么SSH框架中要使用Spring

公告

分类

日历

统计

最新日志

最新评论

链接

归档

其他

< 2010 > < 8 >
日	一	二	三	四	五	六
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31