`
zhaohaolin
  • 浏览: 1010918 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

Spring + iBatis 的多库横向切分简易解决思路

阅读更多

1.引言
   笔者最近在做一个互联网的“类SNS”应用,应用中用户数量巨大(约4000万)左右,因此,简单的使用传统单一数据库存储肯定是不行的。

   参考了业内广泛使用的分库分表,以及使用DAL数据访问层等的做法,笔者决定使用一种最简单的数据源路由选择方式来解决问题。

   严格的说,目前的实现不能算是一个解决方案,只能是一种思路的简易实现,笔者也仅花了2天时间来完成(其中1.5天是在看资料和Spring/ibatis的源码)。这里也只是为各位看官提供一个思路参考,顺便给自己留个笔记。

2.系统的设计前提
   我们的系统使用了16个数据库实例(目前分布在2台物理机器上,后期将根据系统负荷的增加,逐步移库到16台物理机器上)。16个库是根据用户的 UserID进行简单的hash分配。这里值得一说的是,我们既然做了这样的横向切分设计,就已经考虑了系统需求的特性,

  • 1.不会发生经常性的跨库访问。
  • 2.主要的业务逻辑都是围绕UserID为核心的,在一个单库事务内即可完成。



   在系统中,我们使用Spring和iBatis。Spring负责数据库的事务管理AOP,以及Bean间的IOC。选择iBatis的最大原因是对Sql的性能优化,以及后期如果有分表要求的时,可以很容易实现对sql表名替换。


3.设计思路
   首先,要说明一下笔者的思路,其实很简单,即“在每次数据库操作前,确定当前要选择的数据库对象”而后就如同访问单库一样的访问当前选中的数据库即可。

   其次,要在每次DB访问前选择数据库,需要明确几个问题,1.iBatis在什么时候从DataSource中取得具体的数据库Connection 的,2.对取得的Connection,iBatis是否进行缓存,因为在多库情况下Connection被缓存就意味着无法及时改变数据库链接选择。 3.由于我们使用了Spring来管理DB事务,因此必须搞清Spring对DB Connction的开关拦截过程是否会影响多DataSource的情况。

   幸运的是,研究源码的结果发现,iBatis和Spring都是通过标准的DataSource接口来控制
Connection的,这就为我们省去了很多的麻烦,只需要实现一个能够支持多个数据库的DataSource,就能达到我们的目标。

4.代码与实现
多数据库的DataSource实现:MultiDataSource.class

折叠  Java 代码 复制内容到剪贴板
  1.   
  2. import  java.io.PrintWriter;   
  3. import  java.sql.Connection;   
  4. import  java.sql.SQLException;   
  5. import  java.util.ArrayList;   
  6. import  java.util.Collection;   
  7. import  java.util.HashMap;   
  8. import  java.util.Map;   
  9.   
  10. import  javax.sql.DataSource;   
  11.   
  12. import  org.apache.log4j.Logger;   
  13.   
  14. import  com.xxx.sql.DataSourceRouter.RouterStrategy;   
  15.   
  16. /**  
  17.  * 复合多数据源(Alpha)  
  18.  * @author linliangyi2005@gmail.com  
  19.  * Jul 15, 2010  
  20.  */   
  21. public   class  MultiDataSource  implements  DataSource {   
  22.        
  23.      static  Logger logger = Logger.getLogger(MultiDataSource. class );   
  24.        
  25.      //当前线程对应的实际DataSource   
  26.      private  ThreadLocal<DataSource> currentDataSourceHolder =  new  ThreadLocal<DataSource>();   
  27.      //使用Key-Value映射的DataSource   
  28.      private  Map<String , DataSource> mappedDataSources;   
  29.      //使用横向切分的分布式DataSource   
  30.      private  ArrayList<DataSource> clusterDataSources;   
  31.        
  32.      public  MultiDataSource(){   
  33.         mappedDataSources =  new  HashMap<String , DataSource>( 4 );   
  34.         clusterDataSources =  new  ArrayList<DataSource>( 4 );   
  35.     }   
  36.        
  37.      /**  
  38.      * 数据库连接池初始化  
  39.      * 该方法通常在web 应用启动时调用  
  40.      */   
  41.      public   void  initialMultiDataSource(){   
  42.          for (DataSource ds : clusterDataSources){   
  43.              if (ds !=  null ){   
  44.                 Connection conn =  null ;   
  45.                  try  {   
  46.                     conn = ds.getConnection();                     
  47.                 }  catch  (SQLException e) {   
  48.                     e.printStackTrace();   
  49.                 }  finally {   
  50.                      if (conn !=  null ){   
  51.                          try  {   
  52.                             conn.close();   
  53.                         }  catch  (SQLException e) {   
  54.                             e.printStackTrace();   
  55.                         }   
  56.                         conn =  null ;   
  57.                     }   
  58.                 }   
  59.             }   
  60.         }   
  61.         Collection<DataSource> dsCollection = mappedDataSources.values();   
  62.          for (DataSource ds : dsCollection){   
  63.              if (ds !=  null ){   
  64.                 Connection conn =  null ;   
  65.                  try  {   
  66.                     conn = ds.getConnection();   
  67.                 }  catch  (SQLException e) {   
  68.                     e.printStackTrace();   
  69.                 }  finally {   
  70.                      if (conn !=  null ){   
  71.                          try  {   
  72.                             conn.close();   
  73.                         }  catch  (SQLException e) {   
  74.                             e.printStackTrace();   
  75.                         }   
  76.                         conn =  null ;   
  77.                     }   
  78.                 }   
  79.             }   
  80.         }   
  81.     }   
  82.      /**  
  83.      * 获取当前线程绑定的DataSource  
  84.      * @return  
  85.      */   
  86.      public  DataSource getCurrentDataSource() {   
  87.          //如果路由策略存在,且更新过,则根据路由算法选择新的DataSource   
  88.         RouterStrategy strategy = DataSourceRouter.currentRouterStrategy.get();   
  89.          if (strategy ==  null ){   
  90.              throw   new  IllegalArgumentException( "DataSource RouterStrategy No found." );   
  91.         }          
  92.          if (strategy !=  null  && strategy.isRefresh()){              
  93.              if (RouterStrategy.SRATEGY_TYPE_MAP.equals(strategy.getType())){   
  94.                  this .choiceMappedDataSources(strategy.getKey());   
  95.                    
  96.             } else   if (RouterStrategy.SRATEGY_TYPE_CLUSTER.equals(strategy.getType())){   
  97.                  this .routeClusterDataSources(strategy.getRouteFactor());   
  98.             }              
  99.             strategy.setRefresh( false );   
  100.         }   
  101.          return  currentDataSourceHolder.get();   
  102.     }   
  103.   
  104.      public  Map<String, DataSource> getMappedDataSources() {   
  105.          return  mappedDataSources;   
  106.     }   
  107.   
  108.      public   void  setMappedDataSources(Map<String, DataSource> mappedDataSources) {   
  109.          this .mappedDataSources = mappedDataSources;   
  110.     }   
  111.   
  112.      public  ArrayList<DataSource> getClusterDataSources() {   
  113.          return  clusterDataSources;   
  114.     }   
  115.   
  116.      public   void  setClusterDataSources(ArrayList<DataSource> clusterDataSources) {   
  117.          this .clusterDataSources = clusterDataSources;   
  118.     }   
  119.        
  120.      /**  
  121.      * 使用Key选择当前的数据源  
  122.      * @param key  
  123.      */   
  124.      public   void  choiceMappedDataSources(String key){   
  125.         DataSource ds =  this .mappedDataSources.get(key);   
  126.          if (ds ==  null ){   
  127.              throw   new  IllegalStateException( "No Mapped DataSources Exist!" );   
  128.         }   
  129.          this .currentDataSourceHolder.set(ds);   
  130.     }   
  131.        
  132.      /**  
  133.      * 使用取模算法,在群集数据源中做路由选择  
  134.      * @param routeFactor  
  135.      */   
  136.      public   void  routeClusterDataSources( int  routeFactor){   
  137.          int  size =  this .clusterDataSources.size();   
  138.          if (size ==  0 ){   
  139.              throw   new  IllegalStateException( "No Cluster DataSources Exist!" );   
  140.         }   
  141.          int  choosen = routeFactor % size;   
  142.         DataSource ds =  this .clusterDataSources.get(choosen);   
  143.          if (ds ==  null ){   
  144.              throw   new  IllegalStateException( "Choosen DataSources is null!" );   
  145.         }   
  146.         logger.debug( "Choosen DataSource No."  + choosen+  " : "  + ds.toString());   
  147.          this .currentDataSourceHolder.set(ds);   
  148.     }   
  149.   
  150.      /* (non-Javadoc)  
  151.      * @see javax.sql.DataSource#getConnection()  
  152.      */   
  153.      public  Connection getConnection()  throws  SQLException {   
  154.          if (getCurrentDataSource() !=  null ){   
  155.              return  getCurrentDataSource().getConnection();   
  156.         }   
  157.          return   null ;   
  158.     }   
  159.   
  160.      /* (non-Javadoc)  
  161.      * @see javax.sql.DataSource#getConnection(java.lang.String, java.lang.String)  
  162.      */   
  163.      public  Connection getConnection(String username, String password)   
  164.              throws  SQLException {   
  165.          if (getCurrentDataSource() !=  null ){   
  166.              return  getCurrentDataSource().getConnection(username , password);   
  167.         }   
  168.          return   null ;   
  169.     }   
  170.   
  171.      /* (non-Javadoc)  
  172.      * @see javax.sql.CommonDataSource#getLogWriter()  
  173.      */   
  174.      public  PrintWriter getLogWriter()  throws  SQLException {   
  175.          if (getCurrentDataSource() !=  null ){   
  176.              return  getCurrentDataSource().getLogWriter();   
  177.         }   
  178.          return   null ;   
  179.     }   
  180.   
  181.      /* (non-Javadoc)  
  182.      * @see javax.sql.CommonDataSource#getLoginTimeout()  
  183.      */   
  184.      public   int  getLoginTimeout()  throws  SQLException {   
  185.          if (getCurrentDataSource() !=  null ){   
  186.              return  getCurrentDataSource().getLoginTimeout();   
  187.         }   
  188.          return   0 ;   
  189.     }   
  190.   
  191.      /* (non-Javadoc)  
  192.      * @see javax.sql.CommonDataSource#setLogWriter(java.io.PrintWriter)  
  193.      */   
  194.      public   void  setLogWriter(PrintWriter out)  throws  SQLException {   
  195.          if (getCurrentDataSource() !=  null ){   
  196.             getCurrentDataSource().setLogWriter(out);   
  197.         }   
  198.     }   
  199.   
  200.      /* (non-Javadoc)  
  201.      * @see javax.sql.CommonDataSource#setLoginTimeout(int)  
  202.      */   
  203.      public   void  setLoginTimeout( int  seconds)  throws  SQLException {   
  204.          if (getCurrentDataSource() !=  null ){   
  205.             getCurrentDataSource().setLoginTimeout(seconds);   
  206.         }   
  207.     }   
  208.   
  209.      /* (non-Javadoc)  
  210.      * 该接口方法since 1.6  
  211.      * 不是所有的DataSource都实现有这个方法  
  212.      * @see java.sql.Wrapper#isWrapperFor(java.lang.Class)  
  213.      */   
  214.      public   boolean  isWrapperFor(Class<?> iface)  throws  SQLException {   
  215.            
  216. //      if(getCurrentDataSource() != null){   
  217. //          return getCurrentDataSource().isWrapperFor(iface);   
  218. //      }   
  219.          return   false ;   
  220.     }   
  221.   
  222.      /* (non-Javadoc)  
  223.      * 该接口方法since 1.6  
  224.      * 不是所有的DataSource都实现有这个方法  
  225.      * @see java.sql.Wrapper#unwrap(java.lang.Class)  
  226.      */   
  227.      public  <T> T unwrap(Class<T> iface)  throws  SQLException {   
  228. //      if(getCurrentDataSource() != null){   
  229. //          return getCurrentDataSource().unwrap(iface);   
  230. //      }   
  231.          return   null ;   
  232.     }  


这个类实现了DataSource的标准接口,而最核心的部分是getConnection()方法的重载。下面具体阐述:

  • 1.实例变量 clusterDataSources 是一个DataSource 的 ArrayList它存储了多个数据库的DataSource实例,我们使用Spring的IOC功能,将多个DataSource注入到这个list中。
  • 2. 实例变量 mappedDataSources 是一个DataSource 的Map,它与clusterDataSources 一样用来存储多个数据库的DataSource实例,不同的是,它可以使用key直接获取DataSource。我们一样会使用Spring的IOC功 能,将多个DataSource注入到这个Map中。
  • 3.实例变量currentDataSourceHolder ,他是一个ThreadLocal变量,保存与当前线程相关的且已经取得的DataSource实例。这是为了在同一线程中,多次访问同一数据库时,不需要再重新做路由选择。
  • 4.当外部类调用getConnection()方法时,方法将根据上下文的路由规则,从clusterDataSources 或者 mappedDataSources 选择对应DataSource,并返回其中的Connection。


(PS: 关于DataSource的路由选择规则,可以根据应用场景的不同,自行设计。笔者这里提供两种简单的思路,1.根据HashCode,在上述例子中可以 是UserId,进行取模运算,来定位数据库。2.根据上下文设置的关键字key,从map中选择映射的DataSource)


5.将MultiDataSource与Spring,iBatis结合
    在完成了上述的编码过程后,就是将这个MultiDataSource与现有Spring和iBatis结合起来配置。

STEP 1。配置多个数据源
笔者这里使用了C3P0作为数据库连接池,这一步和标准的Spring配置一样,唯一不同的是,以前只配置一个,现在要配置多个

折叠  XML/HTML 代码 复制内容到剪贴板
  1. <!-- jdbc连接池-1-->   
  2. < bean     id = "c3p0_dataSource_1"    class = "com.mchange.v2.c3p0.ComboPooledDataSource"     destroy-method = "close" >       
  3.      < property   name = "driverClass" >       
  4.          < value > ${jdbc.driverClass} </ value >       
  5.      </ property >       
  6.      < property   name = "jdbcUrl" >       
  7.          < value > ${mysql.url_1} </ value >       
  8.         </ property >       
  9.      < property   name = "user" >       
  10.          < value > ${jdbc.username} </ value >       
  11.      </ property >       
  12.      < property   name = "password" >       
  13.          < value > ${jdbc.password} </ value >       
  14.      </ property >        
  15.      <!--连接池中保留的最小连接数。-->       
  16.      < property   name = "minPoolSize" >       
  17.             < value > ${c3p0.minPoolSize} </ value >       
  18.         </ property >        
  19.      <!--连接池中保留的最大连接数。Default: 15 -->       
  20.         < property   name = "maxPoolSize" >       
  21.          < value > ${c3p0.maxPoolSize} </ value >       
  22.      </ property >       
  23.      <!--初始化时获取的连接数,取值应在minPoolSize与maxPoolSize之间。Default: 3 -->       
  24.         < property   name = "initialPoolSize" >       
  25.          < value > ${c3p0.initialPoolSize} </ value >       
  26.      </ property >     
  27.      <!--每60秒检查所有连接池中的空闲连接。Default: 0 -->       
  28.         < property   name = "idleConnectionTestPeriod" >       
  29.             < value > ${c3p0.idleConnectionTestPeriod} </ value >       
  30.         </ property >       
  31.     </ bean >     
  32.       
  33. <!------------- jdbc连接池-2------------------->   
  34. < bean     id = "c3p0_dataSource_2"    class = "com.mchange.v2.c3p0.ComboPooledDataSource"     destroy-method = "close" >       
  35.      < property   name = "driverClass" >       
  36.          < value > ${jdbc.driverClass} </ value >       
  37.      </ property >       
  38.      < property   name = "jdbcUrl" >       
  39.          < value > ${mysql.url_2} </ value >       
  40.         </ property >       
  41.      < property   name = "user" >       
  42.          < value > ${jdbc.username} </ value >       
  43.      </ property >       
  44.      < property   name = "password" >       
  45.          < value > ${jdbc.password} </ value >       
  46.      </ property >        
  47.      <!--连接池中保留的最小连接数。-->       
  48.      < property   name = "minPoolSize" >       
  49.             < value > ${c3p0.minPoolSize} </ value >       
  50.         </ property >        
  51.      <!--连接池中保留的最大连接数。Default: 15 -->       
  52.         < property   name = "maxPoolSize" >       
  53.          < value > ${c3p0.maxPoolSize} </ value >       
  54.      </ property >       
  55.      <!--初始化时获取的连接数,取值应在minPoolSize与maxPoolSize之间。Default: 3 -->       
  56.         < property   name = "initialPoolSize" >       
  57.          < value > ${c3p0.initialPoolSize} </ value >       
  58.      </ property >     
  59.      <!--每60秒检查所有连接池中的空闲连接。Default: 0 -->       
  60.         < property   name = "idleConnectionTestPeriod" >       
  61.             < value > ${c3p0.idleConnectionTestPeriod} </ value >       
  62.         </ property >       
  63.     </ bean >   
  64.   
  65.     <!------------- 更多的链接池配置------------------->   
  66.    ......  


STEP 2。将多个数据源都注入到MultiDataSource中

折叠  XML/HTML 代码 复制内容到剪贴板
  1.     < bean   id = "multiDataSource"     class = "com.xxx.sql.MultiDataSource" >   
  2.      < property   name = "clusterDataSources" >   
  3.          < list >   
  4.              < ref   bean = "c3p0_dataSource_1"   />   
  5.              < ref   bean = "c3p0_dataSource_2"   />   
  6.              < ref   bean = "c3p0_dataSource_3"   />   
  7.              < ref   bean = "c3p0_dataSource_4"   />   
  8.              < ref   bean = "c3p0_dataSource_5"   />   
  9.              < ref   bean = "c3p0_dataSource_6"   />   
  10.              < ref   bean = "c3p0_dataSource_7"   />   
  11.              < ref   bean = "c3p0_dataSource_8"   />   
  12.          </ list >   
  13.      </ property >   
  14.      < property   name = "mappedDataSources" >   
  15.          < map >   
  16.              < entry   key = "system"   value-ref = "c3p0_dataSource_system"   />   
  17.          </ map >   
  18.      </ property >   
  19. </ bean >   


STEP 3。像使用标准的DataSource一样,使用MultiDataSource

折叠  XML/HTML 代码 复制内容到剪贴板
  1. <!--  iBatis Client配置 将 MultiDataSource 与iBatis Client 绑定-->   
  2. < bean   id = "sqlMapClient"   class = "org.springframework.orm.ibatis.SqlMapClientFactoryBean" >   
  3.          < property   name = "configLocation"   value = "classpath:SqlMapConfig.xml" />   
  4.      < property   name = "dataSource"   ref = "multiDataSource" > </ property >   
  5. </ bean >   
  6.   
  7. <!-- jdbc事务管理配置 将 MultiDataSource 与事务管理器绑定-->   
  8. < bean   id = "jdbc_TransactionManager"   class = "org.springframework.jdbc.datasource.DataSourceTransactionManager" >   
  9.      < property   name = "dataSource"   ref = "multiDataSource" > </ property >   
  10. </ bean >   

至此,我们的程序就可以让Spring来管理多库访问了,但请注意,数据库事务仍然限于单库范围(之前已经说过,这里的应用场景不存在跨库的事务)。


6.Java代码使用例子
首先要说明的是,这里我们只是提供了一个简单的使用范例,在范例中,我们还必须手动的调用API,以确定DataSource的路由规则,在实际的应用中,您可以针对自己的业务特点,对此进行封装,以实现相对透明的路由选择

折叠  Java 代码 复制内容到剪贴板
  1. public   boolean  addUserGameInfo(UserGameInfo userGameInfo){   
  2.      //1.根据UserGameInfo.uid 进行数据源路由选择   
  3.     DataSourceRouter.setRouterStrategy(   
  4.             RouterStrategy.SRATEGY_TYPE_CLUSTER ,   
  5.              null ,   
  6.             userGameInfo.getUid());   
  7.        
  8.      //2.数据库存储   
  9.      try  {   
  10.         userGameInfoDAO.insert(userGameInfo);   
  11.          return   true ;   
  12.     }  catch  (SQLException e) {   
  13.         e.printStackTrace();   
  14.         logger.debug( "Insert UserGameInfo failed. "  + userGameInfo.toString());   
  15.     }   
  16.      return   false ;   
  17. }  


OK,我们的多库横向切分的实验可以暂告一个段落。实际上,要实现一个完整的DAL是非常庞大的工程,而对我们推动巨大的,可能只是很小的一个部分,到处都存在着8-2法则,要如何选择,就看各位看官了!!

分享到:
评论

相关推荐

    spring+ibatis事务的配置

    很好的spring+ibatis事务的配置文档.

    struts2+spring+ibatis+mysql

    "Struts2+Spring+Ibatis+MySQL" 是一个经典的Java Web开发框架组合,用于构建高效、可扩展的企业级应用程序。这个组合集成了强大的MVC(Model-View-Controller)框架Struts2、依赖注入与面向切面编程的Spring框架、...

    Struts2+Spring+Hibernate和Struts2+Spring+Ibatis

    Struts2+Spring+Hibernate和Struts2+Spring+Ibatis是两种常见的Java Web应用程序集成框架,它们分别基于ORM框架Hibernate和轻量级数据访问框架Ibatis。这两种框架结合Spring,旨在提供一个强大的、可扩展的、易于...

    struts2+spring+Ibatis框架包

    总的来说,这个"struts2+spring+iBatis框架包"提供了从用户界面到数据库的完整解决方案,简化了开发流程,提高了代码的可维护性和可测试性。在实际开发中,开发者可以根据需求进一步定制和扩展这三个框架的功能,以...

    maven搭建SpringMVC+spring+ibatis

    在IT行业中,构建高效、可扩展的Web应用是至关重要的,而"Maven搭建SpringMVC+Spring+Ibatis"的组合则提供了一种强大的解决方案。本文将深入探讨这些技术及其集成,帮助你理解和掌握如何利用它们来构建现代化的Java ...

    struts+spring+ibatis做的一个增删改查例子

    在Struts+Spring+iBATIS的架构中,iBATIS负责与数据库交互,通过SQL映射文件(sqlmap.xml)定义SQL查询、插入、更新和删除操作。它与Spring整合后,可以在Spring的事务管理下执行数据库操作,确保数据的一致性。 在...

    JSF+Spring+Ibatis示例

    JSF+Spring+Ibatis示例,对学习JAVA企业应用开发有巨大的帮助!

    struts2 + spring + ibatis 实例

    struts2 + spring + ibatis 实例 struts2 + spring + ibatis 实例 struts2 + spring + ibatis 实例 struts2 + spring + ibatis 实例 struts2 + spring + ibatis 实例

    maven3+struts2+spring+ibatis

    maven3+struts2+spring+ibatis,本来是用maven3+struts2+spring+hibernate但考虑到hibernate在多表级联查询的时候执行效率不高,所以改用性能更好不过sql比较麻烦的的ibatis,本项目只有登录和插入数据,仅供参考: ...

    spring+struts2+ibatis整合的jar包

    总的来说,Spring、Struts2和iBatis的整合为Java Web开发提供了一个强大、灵活的解决方案,让开发者能够更专注于业务逻辑,而不是框架的底层实现。通过合理的配置和使用这个jar包,开发者可以快速构建出稳定、高性能...

    spring+ibatis+oracle分页缓存源码

    总的来说,"spring+ibatis+oracle分页缓存源码"项目展示了如何在Spring管理的环境中,利用iBatis和Oracle数据库实现高效的数据分页和缓存策略。通过理解和实践这些技术,开发者可以构建出更加健壮、响应快速的Web...

    webwork+spring+ibatis很适合初学者的实例

    "webwork+spring+ibatis" 的实例通常会展示如何将这三个框架集成到一个完整的Web项目中。这个实例可能包含以下部分: 1. **环境配置**:安装和配置Java开发环境,如JDK,以及相关的开发工具,如IDEA或Eclipse。 2. ...

    struts+spring+ibatis的Demo

    这个"struts+spring+ibatis的Demo"压缩包文件提供了这三个框架集成使用的示例代码,旨在帮助开发者理解和学习如何将它们有效地结合在一起。 **Struts 2框架** Struts 2是一个基于MVC设计模式的Web应用框架,它继承...

    Struts+Spring+Ibatis环境配置(一) - zwjxf的专栏 - 博

    Struts+Spring+Ibatis环境配置(一) - zwjxf的专栏 - 博

    spring+struts2+ibatis简单登录实例--特别适新人学习

    一个简单的spring+struts+ibatis整合的实例,实现了用户登录,用户登录成功则显示欢迎信息,失败则显示用户名或密码错误,该实例非常简单基础,特别适合新人学习,工程包含了必要的资源包,部署到服务器中及可运行,...

    struts+spring+ibatis框架

    在"struts+spring+ibatis"的整合应用中,Spring通常作为核心,管理Struts的Action以及iBatis的数据访问对象(DAO)。Struts处理HTTP请求,将请求转发给Spring管理的Action,Action再通过Spring的依赖注入获取到...

    struts2+hibernate+spring+ibatis 小实例

    struts2+hibernate+spring+ibatis 小实例struts2+hibernate+spring+ibatis 小实例struts2+hibernate+spring+ibatis 小实例struts2+hibernate+spring+ibatis 小实例struts2+hibernate+spring+ibatis 小实例struts2+...

    各种系统架构图及其简介(Spring+IBatis+Struts1+Struts2+Hibernat)

    各种系统架构图及其简介(Spring+IBatis+Struts1+Struts2+Hibernat)

    Struts2+Spring+Ibatis整合的简单人事管理系统

    Struts2+Spring+Ibatis整合的简单人事管理系统 没分了,转载过来的,有需要的看看吧,我觉得不错~~

    Spring+Struts+ibatis讲解

    在Spring+Struts+ibatis这种经典的Java Web开发框架组合中,主要涉及到三层架构:表现层(Action)、业务逻辑层(Service)和数据访问层(DAO)。这些组件协同工作,实现了应用程序的功能。以下是对各部分的详细解释...

Global site tag (gtag.js) - Google Analytics