Spring MVC 3.1

最新推荐文章于 2021-07-06 19:34:21 发布
置顶 最新推荐文章于 2021-07-06 19:34:21 发布
阅读量1k 收藏
点赞数
分类专栏： hibernate spring 文章标签： Hibernate Spring MVC Cache
1、搭建景象。

　　　　1）Spring3.1.2的公布包；Hibernate4.1.7的公布包（没有应用hibernate的API，只是应用了它对JPA的实现）； BoneCP 连接池框架及其依附的jar，缓存框架ehcache，全部所用到的jar包如下：　　

antlr-2.7.7.jar
bonecp-0.7.1.RELEASE.jar
bonecp-provider-0.7.1-rc2.jar
bonecp-spring-0.7.1-rc1.jar
com.springsource.net.sf.cglib-2.2.0.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.apache.commons.logging-1.1.1.jar
com.springsource.org.aspectj.weaver-1.6.12.RELEASE.jar
dom4j-1.6.1.jar
ehcache-core-2.5.2.jar
guava-12.0.jar
hibernate-commons-annotations-4.0.1.Final.jar
hibernate-core-4.1.7.Final.jar
hibernate-entitymanager-4.1.7.Final.jar
hibernate-jpa-2.0-api-1.0.1.Final.jar
javassist-3.15.0-GA.jar
jboss-logging-3.1.0.GA.jar
jboss-transaction-api_1.1_spec-1.0.0.Final.jar
log4j-1.2.17.jar
mysql-connector-java-5.1.6-bin.jar
org.springframework.aop-3.1.2.RELEASE.jar
org.springframework.asm-3.1.2.RELEASE.jar
org.springframework.aspects-3.1.2.RELEASE.jar
org.springframework.beans-3.1.2.RELEASE.jar
org.springframework.context-3.1.2.RELEASE.jar
org.springframework.context.support-3.1.2.RELEASE.jar
org.springframework.core-3.1.2.RELEASE.jar
org.springframework.expression-3.1.2.RELEASE.jar
org.springframework.instrument-3.1.2.RELEASE.jar
org.springframework.instrument.tomcat-3.1.2.RELEASE.jar
org.springframework.jdbc-3.1.2.RELEASE.jar
org.springframework.jms-3.1.2.RELEASE.jar
org.springframework.orm-3.1.2.RELEASE.jar
org.springframework.oxm-3.1.2.RELEASE.jar
org.springframework.test-3.1.2.RELEASE.jar
org.springframework.transaction-3.1.2.RELEASE.jar
org.springframework.web-3.1.2.RELEASE.jar
org.springframework.web.portlet-3.1.2.RELEASE.jar
org.springframework.web.servlet-3.1.2.RELEASE.jar
slf4j-api-1.6.1.jar
slf4j-nop-1.6.1.jar

 　　2）建树一个Web Project，引入上述jar包

　　　　2.1）web.xml设备如下：

<？xml version="1.0" encoding="UTF-8"？>
<web-app version="2.5" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    
    <!-- 设备Log4j -->
    <context-param>
          <param-name>webAppRootKey</param-name>
          <param-value>spring_springmvc_jpa.root</param-value>
    </context-param>
    <context-param>
          <param-name>log4jConfigLocation</param-name>
          <param-value>classpath:log4j.properties</param-value>
    </context-param>
    <listener>
          <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
    </listener>
    
    <!-- 设备编码过滤器 -->
    <filter>
          <filter-name>characterEncodingFilter</filter-name>
          <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
          <init-param>
                <param-name>encoding</param-name>
                <param-value>UTF-8</param-value>
          </init-param>
    </filter>
    <filter-mapping>
          <filter-name>characterEncodingFilter</filter-name>
          <url-pattern>/*</url-pattern>
    </filter-mapping>
    
    <!-- 设备Spring器 -->
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>

    <!-- Spring 刷新Introspector防止内存泄漏 -->
    <listener>
        <listener-class>
            org.springframework.web.util.IntrospectorCleanupListener
        </listener-class>
    </listener>

    
    <!-- SpringMVC核心分发器 -->
    <servlet> 
          <servlet-name>dispatcherServlet</servlet-name> 
          <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
          <init-param> 
                  <param-name>contextConfigLocation</param-name> 
                  <param-value>/WEB-INF/dispatcher-servlet.xml</param-value> 
          </init-param> 
          <load-on-startup>1</load-on-startup> 
     </servlet> 
     <!-- 映射*.do的恳求 -->
     <servlet-mapping> 
             <servlet-name>dispatcherServlet</servlet-name> 
             <url-pattern>*.do</url-pattern> 
     </servlet-mapping> 

    
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

　　　　2.2）在src目次下建树log4j.properties日记设备文件，内容如下：

log4j.rootLogger=INFO，stdout，file

＃应用于把握台 
log4j.appender.stdout=org.apache.log4j.ConsoleAppender 
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout 
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout.ConversionPattern=％-d{yyyy-MM-dd HH:mm:ss，SSS} [％c]-[％p] ％m％n 
＃应用于文件 
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender 
log4j.appender.file.File=￥{spring_springmvc_jpa.root}/app.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout 
log4j.appender.R.layout.ConversionPattern=％d{yyyy-MM-dd HH:mm:ss，SSS} [％t] [％c] [％p] - ％m％n


log4j.logger.org.hibernate.tool.hbm2ddl=debug

　　　　2.3）在src目次下建树缓存的设备文件ehcache.xml，内容如下：

<？xml version="1.0" encoding="UTF-8"？>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="ehcache.xsd"
         Check="true" monitoring="autodetect"
         dynamicConfig="true">

   <!--  <diskStore path="java.io.tmpdir"/> -->
   
   <!-- 设备缓存文件存放路径 -->
   <diskStore path="E:/CacheTmpDir" />

   <!--   
        
        1.必必要有的属性：   
        
        name: cache的名字，用来辨认不合的cache，必须惟一。   
        
        maxElementsInMemory: 内存经管的缓存元素数量最大限值。   
        
        maxElementsOnDisk: 硬盘经管的缓存元素数量最大限值。默认值为0，就是没有限制。   
        
        eternal: 设定元素是否持久话。若设为true，则缓存元素不会过期。   
        
        overflowToDisk: 设定是否在内存填满的时辰把数据转到磁盘上。   
        
        2.下面是一些可选属性：   
        
        timeToIdleSeconds： 设定元素在过期前余暇状况的时候，只对非持久性缓存对象有效。默认值为0，值为0意味着元素可以闲置至无穷长时候。   
        
        timeToLiveSeconds: 设定元素从创建到过期的时候。其他与timeToIdleSeconds类似。   
        
        diskPersistent: 设定在虚拟机重启时是否进行磁盘存储，默认为false.（我的直觉，对于安然小型应用，宜设为true）。   
        
        diskExpiryThreadIntervalSeconds: 接见磁盘线程活动时候。   
        
        diskSpoolBufferSizeMB: 存入磁盘时的缓冲区大小，默认30MB，每个缓存都有本身的缓冲区。   
        
        memoryStoreEvictionPolicy: 元素逐出缓存规矩。共有三种，Recently Used （LRU）比来起码应用，为默认。
        First In First Out （FIFO），进步前辈先出。Less Frequently Used（specified as LFU）起码应用  
        
    -->
   
  <defaultCache maxElementsInMemory="10000"
                    eternal="false"
                    timeToIdleSeconds="120" 
                    timeToLiveSeconds="120" 
                    overflowToDisk="true"
                    maxElementsOnDisk="10000000" 
                    diskPersistent="false"
                    diskExpiryThreadIntervalSeconds="120" 
                    memoryStoreEvictionPolicy="LRU" />
                    
    <!-- User cache -->
    <cache name="userCache"
          maxElementsInMemory="10000"
          maxElementsOnDisk="1000"
          eternal="false"
          overflowToDisk="true"
          diskSpoolBufferSizeMB="20" 
          timeToIdleSeconds="300"
          timeToLiveSeconds="600" 
          memoryStoreEvictionPolicy="LFU" />
          
</ehcache>

　　　　2.4）在src目次下建树数据库连接属性设备文件jdbc.properties，内容如下：

＃mysql数据库用
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_springmvc_jpa？useUnicode=true&amp;characterEncoding=UTF-8
jdbc.username=root
jdbc.password=root


＃＃===============BoneCP设备==============＃＃

＃搜检数据库连接池中余暇连接的间隔时候，单位是分，默认值：240，若是要作废则设置为0＃
BoneCP.idleConnectionTestPeriod=60

＃连接池中未应用的链接最大存活时候，单位是分，默认值：60，若是要永远存活设置为0＃ 
BoneCP.idleMaxAge=60

＃每个分区最大的连接数＃  
BoneCP.maxConnectionsPerPartition=5

＃每个分区最小的连接数＃  
BoneCP.minConnectionsPerPartition=1

＃分区数 ，默认值2，最小1，推荐3-4，视应用而定＃  
BoneCP.partitionCount=3

＃每次去拿数据库连接的时辰一次性要拿几个，默认值：2＃  
BoneCP.acquireIncrement=2  

＃缓存prepared statements的大小，默认值：0＃  
BoneCP.statementsCacheSize=0 

＃每个分区开释链接助理过程的数量，默认值：3，除非你的一个数据库连接的时候内做了很多工作，不然过多的助理过程会影响你的机能＃  
BoneCP.releaseHelperThreads=3

　　　　　2.5）在WEB-INF目次下建树Spring的设备文件applicationContext.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:tx="http://www.springframework.org/schema/tx"
               xmlns:context="http://www.springframework.org/schema/context"
               xmlns:p="http://www.springframework.org/schema/p"  
               xmlns:cache="http://www.springframework.org/schema/cache"  
               xsi:schemaLocation="
                    http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
                    http://www.springframework.org/schema/tx 
                    http://www.springframework.org/schema/tx/spring-tx-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/cache 
                     http://www.springframework.org/schema/cache/spring-cache-3.1.xsd">    

        
        <!-- 注解支撑 -->
        <context:annotation-config />
        
        <!-- 启动组件扫描，打消＠Controller组件，该组件由SpringMVC设备文件扫描 -->
        <context:component-scan base-package="cn.luxh.app">
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>  
        </context:component-scan> 
    
        <!-- 属性文件地位 -->
        <context:property-placeholder location="classpath:jdbc.properties" /> 
        
        <!-- 数据源 -->
        <bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource" destroy-method="close">
            <!-- 数据库驱动 -->
            <property name="driverClass" value="￥{jdbc.driverClassName}" />
            <!-- 响应驱动的jdbcUrl-->
            <property name="jdbcUrl" value="￥{jdbc.url}" />
            <!-- 数据库的用户名 -->
            <property name="username" value="￥{jdbc.username}" />
            <!-- 数据库的暗码 -->
            <property name="password" value="￥{jdbc.password}" />
            <!-- 搜检数据库连接池中余暇连接的间隔时候，单位是分，默认值：240，若是要作废则设置为0 -->
            <property name="idleConnectionTestPeriod" value="￥{BoneCP.idleConnectionTestPeriod}" />
            <!-- 连接池中未应用的链接最大存活时候，单位是分，默认值：60，若是要永远存活设置为0 -->
            <property name="idleMaxAge" value="￥{BoneCP.idleMaxAge}" />
            <!-- 每个分区最大的连接数 -->
            <property name="maxConnectionsPerPartition" value="￥{BoneCP.maxConnectionsPerPartition}" />
            <!-- 每个分区最小的连接数 -->
            <property name="minConnectionsPerPartition" value="￥{BoneCP.minConnectionsPerPartition}" />
            <!-- 分区数 ，默认值2，最小1，推荐3-4，视应用而定 -->
            <property name="partitionCount" value="￥{BoneCP.partitionCount}" />
            <!-- 每次去拿数据库连接的时辰一次性要拿几个，默认值：2 -->
            <property name="acquireIncrement" value="￥{BoneCP.acquireIncrement}" />
            <!-- 缓存prepared statements的大小，默认值：0 -->
            <property name="statementsCacheSize" value="￥{BoneCP.statementsCacheSize}" />
            <!-- 每个分区开释链接助理过程的数量，默认值：3，除非你的一个数据库连接的时候内做了很多工作，不然过多的助理过程会影响你的机能 -->
            <property name="releaseHelperThreads" value="￥{BoneCP.releaseHelperThreads}" />
       </bean>
       
       <!-- JPA实体经管器工厂 -->
       <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">  
                    <property name="dataSource" ref="dataSource"/>
       </bean>
       
       <!-- 事务经管器 -->  
       <bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">  
           <property name="entityManagerFactory" ref="entityManagerFactory" />  
       </bean> 
        
       <!-- 注解式事务 --> 
       <tx:annotation-driven transaction-manager="txManager"/>
       
        <!-- 启用缓存注解功能 -->
       <cache:annotation-driven cache-manager="cacheManager"/>
     
       <!-- 声明cacheManager -->   
       <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager"    
               p:cacheManager-ref="ehcache" /> 
      
       <!-- cacheManager工厂类，指定ehcache.xml的地位 -->    
       <bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"
              p:configLocation="classpath:/ehcache.xml"/>

</beans>

　　　　2.6）在WEB-INF目次下建树SpringMVC的设备文件dispatcher-servlet.xml，内容如下：

<？xml version="1.0" encoding="UTF-8"？> 
<beans xmlns="http://www.springframework.org/schema/beans" 
             xmlns:mvc="http://www.springframework.org/schema/mvc" 
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xmlns:context="http://www.springframework.org/schema/context" 
             xsi:schemaLocation=" 
                http://www.springframework.org/schema/beans 
                http://www.springframework.org/schema/beans/spring-beans-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/mvc 
                http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd"> 

       


        <mvc:annotation-driven/> 
        <context:component-scan base-package="cn.luxh.app.controller"/>

        
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 
                <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/> 
                <property name="prefix" value="/WEB-INF/jsp/"/> 
                <property name="suffix" value=".jsp"/> 
        </bean> 

</beans> 
2、编写代码
　　　　1）在WEB-INF目次下建树名叫jsp的文件夹，用于放置jsp页面，和SpringMVC设备文件中的<property name="prefix" value="/WEB-INF/jsp/"/>相对应。
　　　　2）创建一个实体。　　

  
  

   
   
package cn.luxh.app.entity.privilege;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;


/**
 * 用户信息
 * ＠author Luxh
 */

＠Entity
＠Table（name="t_user_info"）
public class UserInfo implements Serializable{

    private static final long serialVersionUID = -3838732995856086555L;
    
    ＠Id
    ＠GeneratedValue
    private Long id;
    
    //账号
    ＠Column（length=20，nullable=false）
    private String account;
    //暗码
    ＠Column（length=20，nullable=false）
    private String password;
    //姓名
    ＠Column（length=32，nullable=false）
    private String name;
    
    //getter、setter
    //......
    

}

  
  
　　　　3）通用DAO，用于其他DAO持续，
　　　　　　3.1）接口

  
  

   
   
package cn.luxh.app.dao.base;

/**
 * 通用的DAO
 * ＠author Luxh
 */
public interface BaseDao {
    
    /**
     * 持久化实体
     * ＠param entity
     */
    void save（Object entity）;
    
    /**
     * 按照主键查询实体
     * ＠param <T>
     * ＠param clazz  实体类
     * ＠param id     主键
     * ＠return
     */
    <T> T getById（Class<T> clazz，Object id）;
}

  
  
　　　　　　3.2）实现

  
  

   
   
package cn.luxh.app.dao.base;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.stereotype.Repository;

/**
 * 通用DAO实现
 * ＠author Luxh
 */

＠Repository
public class BaseDaoImpl implements BaseDao{
    
    //注入实体经管器
    ＠PersistenceContext
    protected EntityManager em;
    
    public <T> T getById（Class<T> clazz， Object id） {
        return em.find（clazz， id）;
    }
    
    public void save（Object entity） {
        em.persist（entity）;
    }
    
}

  
  
　　　　4）UserDao，持续于通用DAO
　　　　　　4.1）接口　　

  
  

   
   
package cn.luxh.app.dao.privilege;

import cn.luxh.app.dao.base.BaseDao;

/**
 * User Dao Interface
 * ＠author Luxh
 */
public interface UserDao extends BaseDao{

}

  
  
　　　　　　4.2）实现

  
  

   
   
package cn.luxh.app.dao.privilege;

import org.springframework.stereotype.Repository;

import cn.luxh.app.dao.base.BaseDaoImpl;

/**
 * User DAO Implement
 * ＠author Luxh
 */

＠Repository
public class UserDaoImpl extends BaseDaoImpl implements UserDao{

}

  
  
　　5）通用的营业接口
　　　　这里只写一个接口，留给其他Service实现。

  
  

   
   
package cn.luxh.app.service.base;

/**
 * 通用营业接口
 * ＠author Luxh
 */
public interface BaseService {
    
    /**
     * 保存实体
     * ＠param entity
     */
    void save（Object entity）;
    
    /**
     * 按照主键获取对象
     * ＠param <T>
     * ＠param clazz 实体类
     * ＠param id    主键
     * ＠return
     */
    <T> T getById（Class<T> clazz，Object id）;
}

  
  
　　　　6）用户营业接口UserService，实现通用营业接口的办法，并加上缓存
　　　　　　6.1）接口

  
  

   
   
package cn.luxh.app.service.privilege;

import cn.luxh.app.service.base.BaseService;

/**
 * User Service
 * ＠author Luxh
 */
public interface UserService extends BaseService {
    
}

  
  
　　　　　　6.2）实现

  
  

   
   
package cn.luxh.app.service.privilege;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import cn.luxh.app.dao.privilege.UserDao;

/**
 * User Service Implement
 * ＠author Luxh
 */

＠Service
public class UserServiceImpl implements UserService{
    
    ＠Autowired
    private UserDao userDao;
    
    ＠Cacheable（value="userCache"）//缓存数据
    public <T> T getById（Class<T> clazz， Object id） {
        return userDao.getById（clazz， id）;
    }

    ＠Transactional（propagation=Propagation.REQUIRED）
    ＠CacheEvict（value="userCache"，allEntries=true）//清除缓存
    public void save（Object entity） {
        userDao.save（entity）;
    }
    
}

  
  
　　　　7）把握层，临时还没有写一个公共的Controller用于被持续，就直接写UserController吧

  
  

   
   
package cn.luxh.app.controller.privilege;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import cn.luxh.app.entity.privilege.UserInfo;
import cn.luxh.app.service.privilege.UserService;


/**
 * User Controller
 * ＠author Luxh
 */

＠Controller
＠RequestMapping（value="/user"）
public class UserController {
    
    private static final Log LOG = LogFactory.getLog（UserController.class）;
    
    
    ＠Autowired
    private UserService userService;//注入营业接口
    
    /**
     * 用户列表
     */
    ＠RequestMapping（value="/userList.do"）
    public String userList（ModelMap modelMap） {
        LOG.info（"接见用户列表"）;
        //打印一句话测试，不查数据库了
        return "user/userList"; //按照SpringMVC设备文件配好的前缀和后缀，主动转为：/WEB-INF/jsp/user/userList.jsp
    }
    
    /**
     * 按照主键查找用户
     */
    ＠RequestMapping（value="/getUserById.do"）
    public String getUserById（＠RequestParam long id） {
        LOG.info（"id is :"+id）;
        UserInfo userInfo = userService.getById（UserInfo.class，id）;
        LOG.info（"user""s name is :"+userInfo.getName（））;
        return "user/userList";
    }
    
    /**
     * 保存用户
     */
    ＠RequestMapping（value="/saveUser.do"）
    public String saveUser（UserInfo userInfo，RedirectAttributes redirectAttributes） {
        LOG.info（"保存用户"）;
        userService.save（userInfo）;
        //重定向后的提示信息，应用RedirectAttributes传递，在JSP页面可以用￥{message}获取
        //提示信息只呈现一次，刷新也不会反复提示，
        redirectAttributes.addFlashAttribute（"message"， "操纵成功"）;
        
        //重定向，防止表单反复提交
        return "redirect:userList.do";//相对于当前路径  
        //return "redirect:/user/userList.do";//相对于当前项目根路径
    }
    

}

  
  
　　　
　　　　　　接见用户列表就是：http://localhost:8080/APP/user/userList.do
　　　　　　按照主键查找用户：http://localhost:8080/APP/user/getUserById.do？id=1
　　　　　　保存用户：http://localhost:8080/APP/user/saveUser.do
无奈的伤城
关注
专栏目录
SpringMVC3.1 + Mybatis3.1实例
06-12
这是一个以SpringMVC3.1 + Mybatis3.1为核心框架的Demo源码，本人经调试并测试通过，供广大初爱好J2EE编程者学习。
springmvc工作原理以及源码分析(基于spring3.1.0)
weixin_30955617的博客
08-11 182
　　springmvc是一个基于spring的web框架.本篇文章对它的工作原理以及源码进行深入分析. 　　一、springmvc请求处理流程 　　二、springmvc的工作机制 　　三、springmvc核心源码分析 　　四、谈谈springmvc的优化 一、springmvc请求处理流程 　　引用spring in action上的一张图来说明了springmvc的核心组件和请求...
spring MVC 3.1 <mvc:annotation-driven>快速配置
iteye_18867的博客
01-04 212
&lt;mvc:annotation-driven&gt; 在spring mvc 3.1增加了此标签的一些新的内置标签，个人能力有限，下面对这个标签进行简要的说明： 以下为可选配置:     &lt;mvc:annotation-driven ignoreDefaultModelOnRedirect="true" conversion-service="" validator="" m...
springMVC 3.1文档
gaohe7091的专栏
07-10 630
出处：http://docs.spring.io/spring/docs/3.1.x/spring-framework-reference/html/mvc.html
3.1 Spring MVC 概述
大风起兮
07-06 106
Spring MVC 是 Spring 提供的一个轻量级的 Web 框架，它实现了 Web MVC 设计模式。 他是Spring 框架的一部分，可以方便的利用 Spring 提供的其他功能 提供了一个前端控制器 DispatchServlet ，使得开发人员无需额外开发控制器对象。 可自动绑定用户输入，并能正确转换数据类型 内置了常见的校验器，可以校验用户输入。 支持国际化，可以根据用户区域显示多国语言 支持多种视图技术，如 JSP、Velocity 和 FreeMarker 等视图技术。 使用基于 XM
spring-mvc-31-demo：演示Spring MVC 3.1特定的自定义选项
03-02
Spring MVC 3.1演示 该项目包含展示样式的微型样本，这些样本演示了Spring MVC 3.1中可用的自定义和功能。 部署该应用程序，导航到主页localhost：8080 / spring-mvc-31-demo并按照此处列出的各种链接进行操作。 该...
spring MVC 3.1 spring security 注解实现安全机制
06-28
总的来说，Spring MVC 3.1和Spring Security 3.1的结合使用，能够帮助开发者快速构建安全、易维护的Web应用。通过注解，我们可以实现对请求、用户角色和权限的精细控制，提高代码的整洁性和可扩展性。尽管这里没有...
spring3.1MVC+mybatis3.1框架集成及事务，分页使用
04-16
在本文中，我们将深入探讨如何将Spring MVC 3.1与MyBatis 3.1框架集成，并讨论其中涉及的关键技术，如事务管理、分页和JSON数据交换。此外，我们还将简要提及开发环境中使用的工具，如Eclipse 4.3、Maven 3.0.5和...
spring_security_3.1
09-14
7. **集成Spring MVC**：Spring Security 3.1与Spring MVC无缝集成，可以方便地保护Web控制器和视图。通过注解，如`@Secured`和`@PreAuthorize`，可以在方法级别声明安全约束。 8. **自定义逻辑**：Spring Security...
Spring3.1搭建的springMVC框架例子
08-31
一个简单SpringMVC例子，从请求到controller跳转再到页面显示能完整执行成功。使用myeclipse6.0搭建，使用Spring3.1部分jar包，使用jdk1.6.0_45和自带的myeclipse tomcat。
spring3.1.0全部jar包
10-11
spring3.1.0全部jar包，里面还有各个jar详细作用，直接下载就可以使用
SpringWebMVC所有常用jar包
09-11
Spring Web MVC开发过程中常用的jar包，解压后复制到/WEN-INF/lib目录下即可使用，快点下载吧。
spring-webmvc-3.1.1.RELEASE.jar.zip
08-23
spring-webmvc-3.1.1.RELEASE.jar.zip
spring mvc用到的jar包 spring-framework-3.1.1
09-23
spring mvc用到的jar包 spring-framework-3.1.1.RELEASE-with-docs.zip和jstl-1.1.2.jar和standard-1.1.2.jar和commons.logging-1.1.1.jar；
Spring 3.1MVC 实战
01-05 4367
Spring 3.1MVC 实战   一、spring3.1 mvc核心思想介绍... 2 二、spring3.1 mvc 框架的特点... 3 三、spring 3.1 MVC入门列子HelloWorld. 3 四、springMVC参数传递... 6 五、springMVC标签介绍... 9 （2）      input标签... 10 （3）checkbox
SpringMVC3.1配置
Taurus的专栏
07-21 245
web.xml文件引入Spring的配置文件   &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="htt
Spring MVC 3.1 Update - 绝好的Spring MVC 3.1学习资料共112页
party
12-26 154
http://rstoyanchev.github.com/spring-mvc-31-update/#1 点此链接，用方向键盘播放和回退 enjoy it
Spring MVC 3.0版本和3.1版本的一点小区别
心有猛虎，细嗅蔷薇
06-12 532
先上代码： 主要是控制器： @Controller public class AccountController { private Map&lt;Long, Account&gt; accounts = new ConcurrentHashMap&lt;Long, Account&gt;(); private static Logger log = LoggerFact...
SpringMVC初学---spring3.1新特性
marshallee的博客
07-14 320
Prior to Spring 3.1, type and method-level request mappings were examined in two separate stages — acontroller was selected first by the DefaultAnnotationHandlerMapping and the actual method toinvok
Spring MVC3.1 Web开发中的请求-响应模型与标准MVC解析
"Spring MVC3.1中文文档是关于Spring框架中MVC模块的详细解释，主要介绍了Web开发中的请求-响应模型以及标准的MVC架构模式。文档旨在帮助开发者理解如何在Web环境中应用MVC设计模式，并区分Web MVC与标准MVC的区别。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值