JAVA学习之（spring + springmvc + mybatis + valocity）及其个人理解

最新推荐文章于 2021-09-28 17:00:45 发布
最新推荐文章于 2021-09-28 17:00:45 发布
阅读量174 收藏
点赞数
分类专栏： 学习笔记 文章标签： javaee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/R_Scholar/article/details/107424008
版权

WEB项目的基本工作原理：

项目启动读取web.xml，加载各种配置文件，由servlet标签配置请求拦截，然后根据配置去跳转servlet或springmvc转发到对应的servlet或Controller去执行业务。
监听器可以理解为（没有考证，纯属个人理解猜测）观察者模式的一中，即注册监听器后，改监听器在以观察者的角度去监督被观察者，一旦发现监听器所监听的相关内容的时候，改观察者就会启动，执行预定好的业务。
过滤器是通过代理实现的，和spring的aop相似，即在每一个请求也可以说每一个servlet的前边加上过滤器要执行的内容。
拦截器：拦截器加载类似于过滤器，在每一个action之前加一段业务代码，但是后边确类似责任链模式，配置的拦截器必须放行才能执行下一个拦截器，只有全部拦截器都放行才能去执行action。

乱码问题解决：

<!-- 解决乱码问题 -->
<filter>
  <filter-name>SpringEncodingFilter</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>
  <init-param>
    <param-name>forceEncoding</param-name>
    <param-value>true</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>SpringEncodingFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

网上的一篇解释特别详细的WEB.XML配置：

<?xml version="1.0" encoding="UTF-8"?>  
<web-app version="3.0" 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/javaeehttp://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">  

    <!-- 在Spring框架中是如何解决从页面传来的字符串的编码问题的呢？
    下面我们来看看Spring框架给我们提供过滤器CharacterEncodingFilter  
     这个过滤器就是针对于每次浏览器请求进行过滤的，然后再其之上添加了父类没有的功能即处理字符编码。  
      其中encoding用来设置编码格式，forceEncoding用来设置是否理会 request.getCharacterEncoding()方法，设置为true则强制覆盖之前的编码格式。-->  
    <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>  
        <init-param>  
            <param-name>forceEncoding</param-name>  
            <param-value>true</param-value>  
        </init-param>  
    </filter>  
    <filter-mapping>  
        <filter-name>characterEncodingFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
    <!-- 项目中使用Spring 时，applicationContext.xml配置文件中并没有BeanFactory，要想在业务层中的class 文件中直接引用Spring容器管理的bean可通过以下方式-->  
    <!--1、在web.xml配置监听器ContextLoaderListener-->  
    <!--ContextLoaderListener的作用就是启动Web容器时，自动装配ApplicationContext的配置信息。因为它实现了ServletContextListener这个接口，在web.xml配置这个监听器，启动容器时，就会默认执行它实现的方法。  
    在ContextLoaderListener中关联了ContextLoader这个类，所以整个加载配置过程由ContextLoader来完成。  
    它的API说明  
    第一段说明ContextLoader可以由 ContextLoaderListener和ContextLoaderServlet生成。  
    如果查看ContextLoaderServlet的API，可以看到它也关联了ContextLoader这个类而且它实现了HttpServlet这个接口  
    第二段，ContextLoader创建的是 XmlWebApplicationContext这样一个类，它实现的接口是WebApplicationContext->ConfigurableWebApplicationContext->ApplicationContext->  
    BeanFactory这样一来spring中的所有bean都由这个类来创建  
     IUploaddatafileManager uploadmanager = (IUploaddatafileManager)    ContextLoaderListener.getCurrentWebApplicationContext().getBean("uploadManager");
     -->  
    <listener>  
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
    </listener>  
    <!--2、部署applicationContext的xml文件-->  
    <!--如果在web.xml中不写任何参数配置信息，默认的路径是"/WEB-INF/applicationContext.xml，  
    在WEB-INF目录下创建的xml文件的名称必须是applicationContext.xml。  
    如果是要自定义文件名可以在web.xml里加入contextConfigLocation这个context参数：  
    在<param-value> </param-value>里指定相应的xml文件名，如果有多个xml文件，可以写在一起并以“,”号分隔。  
    也可以这样applicationContext-*.xml采用通配符，比如这那个目录下有applicationContext-ibatis-base.xml，  
    applicationContext-action.xml，applicationContext-ibatis-dao.xml等文件，都会一同被载入。  
    在ContextLoaderListener中关联了ContextLoader这个类，所以整个加载配置过程由ContextLoader来完成。-->  
    <context-param>  
        <param-name>contextConfigLocation</param-name>  
        <param-value>classpath:spring/applicationContext.xml</param-value>  
    </context-param>  

    <!--如果你的DispatcherServlet拦截"/"，为了实现REST风格，拦截了所有的请求，那么同时对*.js,*.jpg等静态文件的访问也就被拦截了。-->  
    <!--方案一：激活Tomcat的defaultServlet来处理静态文件-->  
    <!--要写在DispatcherServlet的前面， 让 defaultServlet先拦截请求，这样请求就不会进入Spring了，我想性能是最好的吧。-->  
    <servlet-mapping>  
        <servlet-name>default</servlet-name>  
        <url-pattern>*.css</url-pattern>  
    </servlet-mapping>  
    <servlet-mapping>  
        <servlet-name>default</servlet-name>  
        <url-pattern>*.swf</url-pattern>  
    </servlet-mapping>  
    <servlet-mapping>  
        <servlet-name>default</servlet-name>  
        <url-pattern>*.gif</url-pattern>  
    </servlet-mapping>  
    <servlet-mapping>  
        <servlet-name>default</servlet-name>  
        <url-pattern>*.jpg</url-pattern>  
    </servlet-mapping>  
    <servlet-mapping>  
        <servlet-name>default</servlet-name>  
        <url-pattern>*.png</url-pattern>  
    </servlet-mapping>  
    <servlet-mapping>  
        <servlet-name>default</servlet-name>  
        <url-pattern>*.js</url-pattern>  
    </servlet-mapping>  
    <servlet-mapping>  
        <servlet-name>default</servlet-name>  
        <url-pattern>*.html</url-pattern>  
    </servlet-mapping>  
    <servlet-mapping>  
        <servlet-name>default</servlet-name>  
        <url-pattern>*.xml</url-pattern>  
    </servlet-mapping>  
    <servlet-mapping>  
        <servlet-name>default</servlet-name>  
        <url-pattern>*.json</url-pattern>  
    </servlet-mapping>  
    <servlet-mapping>  
        <servlet-name>default</servlet-name>  
        <url-pattern>*.map</url-pattern>  
    </servlet-mapping>  
    <!--使用Spring MVC,配置DispatcherServlet是第一步。DispatcherServlet是一个Servlet,,所以可以配置多个DispatcherServlet-->  
    <!--DispatcherServlet是前置控制器，配置在web.xml文件中的。拦截匹配的请求，Servlet拦截匹配规则要自已定义，把拦截下来的请求，依据某某规则分发到目标Controller(我们写的Action)来处理。-->  
    <servlet>  
        <servlet-name>DispatcherServlet</servlet-name><!--在DispatcherServlet的初始化过程中，框架会在web应用的 WEB-INF文件夹下寻找名为[servlet-name]-servlet.xml 的配置文件，生成文件中定义的bean。-->  
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
        <!--指明了配置文件的文件名，不使用默认配置文件名，而使用dispatcher-servlet.xml配置文件。-->  
        <init-param>  
            <param-name>contextConfigLocation</param-name>  
            <!--其中<param-value>**.xml</param-value> 这里可以使用多种写法-->  
            <!--1、不写,使用默认值:/WEB-INF/<servlet-name>-servlet.xml-->  
            <!--2、<param-value>/WEB-INF/classes/dispatcher-servlet.xml</param-value>-->  
            <!--3、<param-value>classpath*:dispatcher-servlet.xml</param-value>-->  
            <!--4、多个值用逗号分隔-->  
            <param-value>classpath:spring/dispatcher-servlet.xml</param-value>  
        </init-param>  
        <load-on-startup>1</load-on-startup><!--是启动顺序，让这个Servlet随Servletp容器一起启动。-->  
    </servlet>  
    <servlet-mapping>  
        <!--这个Servlet的名字是dispatcher，可以有多个DispatcherServlet，是通过名字来区分的。每一个DispatcherServlet有自己的WebApplicationContext上下文对象。同时保存的ServletContext中和Request对象中.-->  
        <!--ApplicationContext是Spring的核心，Context我们通常解释为上下文环境，我想用“容器”来表述它更容易理解一些，ApplicationContext则是“应用的容器”了:P，Spring把Bean放在这个容器中，在需要的时候，用getBean方法取出-->  
        <servlet-name>DispatcherServlet</servlet-name>  
        <!--Servlet拦截匹配规则可以自已定义，当映射为@RequestMapping("/user/add")时，为例,拦截哪种URL合适？-->  
        <!--1、拦截*.do、*.htm， 例如：/user/add.do,这是最传统的方式，最简单也最实用。不会导致静态文件（jpg,js,css）被拦截。-->  
        <!--2、拦截/，例如：/user/add,可以实现现在很流行的REST风格。很多互联网类型的应用很喜欢这种风格的URL。弊端：会导致静态文件（jpg,js,css）被拦截后不能正常显示。 -->  
        <url-pattern>/</url-pattern> <!--会拦截URL中带“/”的请求。-->  
    </servlet-mapping>  

    <welcome-file-list><!--指定欢迎页面-->  
        <welcome-file>login.html</welcome-file>  
    </welcome-file-list>  
    <error-page> <!--当系统出现404错误，跳转到页面nopage.html-->  
        <error-code>404</error-code>  
        <location>/nopage.html</location>  
    </error-page>  
    <error-page> <!--当系统出现java.lang.NullPointerException，跳转到页面error.html-->  
        <exception-type>java.lang.NullPointerException</exception-type>  
        <location>/error.html</location>  
    </error-page>  
    <session-config><!--会话超时配置，单位分钟-->  
        <session-timeout>360</session-timeout>  
    </session-config>  
</web-app>

WEB.XML配置详解：

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaeehttp://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"> 

    <context-param><!--全局范围内环境参数初始化 即加载各种配置文件--> 
        <!--参数名称--> 
        <param-name>contextConfigLocation</param-name> 
        <!--参数取值--> 
        <param-value>classpath:spring-mybatis.xml</param-value> 
    </context-param> 

    <!--以下配置的加载顺序:先 ServletContext >> context-param >> listener >> filter >> servlet >> spring-->

    <!---------------------------------------------------过滤器配置------------------------------------------------------>
    <!--例:编码过滤器--> 
    <filter>
    <!-- 用来声明filter的相关设定,过滤器可以截取和修改一个Servlet或JSP页面的请求或从一个Servlet或JSP页面发出的响应--> 
        <filter-name>encodingFilter</filter-name> <!--指定filter的名字--> 
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <!--定义filter的类的名称--> 
        <async-supported>true</async-supported> <!--设置是否启用异步支持-->  
        <init-param><!--用来定义参数,若在Servlet可以使用下列方法来获得:String param_name=getServletContext().getInitParamter("param-name里面的值");-->
            <param-name>encoding</param-name> <!--参数名称--> 
            <param-value>UTF-8</param-value> <!--参数值-->
        </init-param>
    </filter>
    <filter-mapping><!--用来定义filter所对应的URL-->
        <filter-name>encodingFilter</filter-name> <!--指定对应filter的名字-->
        <url-pattern>/*</url-pattern> <!--指定filter所对应的URL--> 
    </filter-mapping> 
    
    <!---------------------------------------------------监听器配置------------------------------------------------------> 
    <!--例:spring监听器--> 
    <listener> <!--用来设定Listener接口--> 
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class><!--定义Listener的类名称--> 
    </listener> <!-- 防止Spring内存溢出监听器 --> 
    <listener> 
        <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
    </listener> 

    <!---------------------------------------------------servlet配置------------------------------------------------------>
    <servlet> <!--用来声明一个servlet的数据 即拦截请求，通过springmvc的配置文件中的配置，去转发到对应的Conterller中 -->
        <servlet-name>SpringMVC</servlet-name> <!--指定servlet的名称-->
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <!--指定servlet的类名称,这里配置了前端控制器-->
        <init-param><!--用来定义参数,可有多个init-param。在servlet类中通过getInitParamenter(String name)方法访问初始化参数 -->
            <param-name>contextConfigLocation</param-name> <!--参数名称--> 
            <param-value>classpath:spring-mvc.xml</param-value> <!--参数值-->
        </init-param> 
        <load-on-startup>1</load-on-startup><!--当值为正数或零时：Servlet容器先加载数值小的servlet，再依次加载其他数值大的servlet.-->      
        <async-supported>true</async-supported><!--设置是否启用异步支持--> 
    </servlet> 
    <servlet-mapping><!--用来定义servlet所对应的URL--> 
        <servlet-name>SpringMVC</servlet-name> <!--指定servlet的名称--> 
        <url-pattern>/</url-pattern> <!--指定servlet所对应的URL--> 
    </servlet-mapping>

    <!-----------------------------------------------会话超时配置（单位为分钟）------------------------------------------------->
    <session-config><!--如果某个会话在一定时间未被访问，则服务器可以扔掉以节约内存--> <session-timeout>120</session-timeout> </session-config>

    <!---------------------------------------------------MIME类型配置 ------------------------------------------------------>
    <mime-mapping><!--设定某种扩展名的文件用一种应用程序来打开的方式类型，当该扩展名文件被访问的时候，浏览器会自动使用指定应用程序来打开-->
        <extension>*.ppt</extension> <!--扩展名名称-->
        <mime-type>application/mspowerpoint</mime-type> <!--MIME格式--> 
    </mime-mapping>

    <!---------------------------------------------------欢迎页面配置 ------------------------------------------------------>
    <welcome-file-list><!--定义首页列单.--> 
        <welcome-file>/index.jsp</welcome-file> <!--用来指定首页文件名称.我们可以用<welcome-file>指定几个首页,而服务器会依照设定的顺序来找首页.-->  
        <welcome-file>/index.html</welcome-file> 
    </welcome-file-list>

    <!---------------------------------------------------配置错误页面------------------------------------------------------>
    <error-page> <!--将错误代码(Error Code)或异常(Exception)的种类对应到web应用资源路径.--> 
        <error-code>404</error-code> <!--HTTP Error code,例如: 404、403-->
        <location>error.html</location> <!--用来设置发生错误或异常时要显示的页面-->
    </error-page> 
    <error-page>
        <exception-type>java.lang.Exception</exception-type><!--设置可能会发生的java异常类型,例如:java.lang.Exception--> 
        <location>ExceptionError.html</location> <!--用来设置发生错误或异常时要显示的页面-->
    </error-page> 
</web-app>

Spring工作原理：

IOC：由web.xml加载spring的配置文件，读取配置文件，根据配置文件中的扫描包或者bean标签将一个个实体类加载到spring的容器中，在其他类使用时，直接使用注解、构造方法或set注入进去。

AOP：面向切面，底层原理为动态代理，即将配置了aop的类的前后加一个超类，在此方法之前执行什么业务，在此方法之后执行什么业务，aop一般可以做日志，权限校验，事物控制等，如过滤器就是最好的例子。

Spring配置详解：

<?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:context="http://www.springframework.org/schema/context" 
xmlns:aop="http://www.springframework.org/schema/aop" 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.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd">
    <!-- 开启自动扫包 -->
    <context:component-scan base-package="com.cy.ssm">
        <!--制定扫包规则，不扫描@Controller注解的JAVA类，其他的还是要扫描 -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 启动AOP支持 -->
    <aop:aspectj-autoproxy/>
        
    <!-- 引入外部数据源配置信息 -->
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <value>classpath:datasource.properties</value> <!-- 加载数据库链接属性变量 -->
        </property>
    </bean>
    
    <!-- 配置数据源 尽量使用c3p0或者ali的 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property> <!-- 驱动 -->
        <property name="url" value="${jdbc.url}"></property> <!-- 地址 -->
        <property name="username" value="${jdbc.username}"></property> <!-- 用户名 -->
        <property name="password" value="${jdbc.password}"></property> <!-- 密码 -->
    </bean>

    <!-- 配置Session工厂 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <!-- 加载mybatis.xml文件 --> <!-- mybatis的配置文件，一般会有log的配置在里边 -->
        <property name="configLocation" value="classpath:mybatis.xml"></property>
        <!-- 自动扫描需要定义类别名的包，将包内的JAVA类的类名作为类别名 -->
        <property name="typeAliasesPackage" value="com.cy.ssm.beans"></property>
    </bean>

    <!-- 自动扫描所有的Mapper接口与文件 mybatis才会有 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.cy.ssm.mapper"></property>
    </bean>

    <!-- 配置事务管理器 -->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 定义个通知，指定事务管理器 -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="delete*" propagation="REQUIRED" read-only="false" rollback-for="java.lang.Exception" />
            <tx:method name="save*" propagation="REQUIRED" read-only="false"66 rollback-for="java.lang.Exception" />
            <tx:method name="insert*" propagation="REQUIRED" read-only="false"68 rollback-for="java.lang.Exception" />
            <tx:method name="update*" propagation="REQUIRED" read-only="false"70 rollback-for="java.lang.Exception" />
            <tx:method name="load*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="search*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="select*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <aop:config>
    <!-- 配置一个切入点 -->
    <aop:pointcut id="serviceMethods" expression="execution(* com.cy.ssm.service.impl.*ServiceImpl.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethods" />
    </aop:config>
</beans>

C3P0连接池：
使用：com.mchange.v2.c3p0.ComboPooledDataSource进行配置

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
   <property name="driverClass" value="${jdbc.driver}" />
   <property name="jdbcUrl" value="${jdbc.url}" />
   <property name="user" value="${jdbc.username}" />
   <property name="password" value="${jdbc.password}" />
</bean>

alibaba DRUID连接池：
使用：com.alibaba.druid.pool.DruidDataSource进行配置

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">  
    <!-- 基本属性 url、user、password -->
    <property name="url" value="${jdbc_url}" />
    <property name="username" value="${jdbc_user}" />
    <property name="password" value="${jdbc_password}" />
    <!-- 配置初始化大小、最小、最大 -->
    <property name="initialSize" value="1" />
    <property name="minIdle" value="1" />  
    <property name="maxActive" value="20" />
    <!-- 配置获取连接等待超时的时间 -->
    <property name="maxWait" value="60000" />
    <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
    <property name="timeBetweenEvictionRunsMillis" value="60000" />
    <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
    <property name="minEvictableIdleTimeMillis" value="300000" />
    <property name="validationQuery" value="SELECT 'x'" />
    <property name="testWhileIdle" value="true" />
    <property name="testOnBorrow" value="false" />
    <property name="testOnReturn" value="false" />
    <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
    <property name="poolPreparedStatements" value="true" />
    <property name="maxPoolPreparedStatementPerConnectionSize" value="20" />
    <!-- 配置监控统计拦截的filters，去掉后监控界面sql无法统计 -->
    <property name="filters" value="stat" />  
</bean>

SpringMVC相关注解：

@Configuration：表明这个类是一个配置类，该类需要所在的包需要spring扫描的到
@Bean：@Bean的使用必须基于@Configuration，也就是说@Bean这个注解只能出现在被@Configuration注解标注的class中，@Bean的意思就是将被该注解标注的对象注入到spring容器中，使用时通过@Resource直接引入

SpringMVC的工作原理：

SpringMVC在初始时，需要在web.xml中配置springmvc拦截，拦截到请求之后，根据配置文件中扫描后的信息转发到对应的conterller中，执行业务代码之后，返回对应的视图，通过springmvc的配置去渲染对应的视图，展示给用户查看。

SpringMVC配置详解：

<?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:context="http://www.springframework.org/schema/context" 
xmlns:mvc="http://www.springframework.org/schema/mvc" 
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
    <!-- 启动注解，注册服务，如验证框架、全局类型转换器-->
    <mvc:annotation-driven/>
    <!-- 启动自动扫描 -->
    <context:component-scan base-package="com.cy.ssm">
        <!-- 制定扫包规则 ,只扫描使用@Controller注解的JAVA类 -->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
        
    <!-- 配置springMVC拦截器，做登录校验，即每次访问都会被拦截，然后先执行下边配置的类中的preHandle()，LoginUtils必须实现HandlerInterceptor，然后实现preHandle方法就可以了-->
        <mvc:interceptors>
        <bean class="com.xxx.xxx.xxx.LoginUitls" />
    </mvc:interceptors>
    <!--如果上方的LoginUitls不需要在每一个请求之前执行，那使用下方配置，将拦截特有的URL请求 -->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/admin/*" />
            <bean class="com.base.admin" />
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/caes/*.trl" />
            <bean class="com.base.caes" />
        </mvc:interceptor>
    </mvc:interceptors>

    <!-- 配置视图解析器 -->
    <!-- prefix和suffix：查找视图页面的前缀和后缀（前缀[逻辑视图名]后缀），比如传进来的逻辑视图名为WEB-INF/jsp/hello，则该该jsp视图页面应该存放在“WEB-INF/jsp/hello.jsp”； -->
    <bean class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
        <property name="prefix" value="/"></property> <!-- 我这里的视图直接放在WebRoot下的 -->
        <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

mybaits的工作原理：

通过spring的配置，创建数据会话工厂，引用工厂创建会话，通过会话将sql在数据库中执行，获取数据，返回结果，mybatis是基于反射将JAVA对象中的数据取出作为参数，将返回值通过反射set进JAVA对象的。

WEB项目从无到有开发过程：

1、依赖spring的jar包 （上文）

<!-- Spring依赖 -->
<!-- 1.Spring核心依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.3.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.3.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.7.RELEASE</version>
</dependency>
<!-- 2.Spring dao依赖 -->
<!-- spring-jdbc包括了一些如jdbcTemplate的工具类 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>4.3.7.RELEASE</version>
</dependency>
<!-- 3.Spring web依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>4.3.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.3.7.RELEASE</version>
</dependency>

2、创建spring的配置文件 （上文）

3、在web.xml中加载spring的配置文件

<!-- 定义SPRING配置文件 -->
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>/WEB-INF/conf/data-source.xml</param-value>
</context-param>

4、在web.xml中启动spring的监听器

<!-- 加载spring配置 -->
<listener> <!--用来设定Listener接口-->
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class><!--定义Listener的类名称-->
</listener> <!-- 防止Spring内存溢出监听器 -->
<listener>
  <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>

5、spring到此已经在我们的项目中可以使用了，接下来配置springmvc，首先依然是依赖jia包

<!-- SLF4J API -->
<!-- SLF4J 是一个日志抽象层，允许你使用任何一个日志系统，并且可以随时切换还不需要动到已经写好的程序 -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.22</version>
</dependency>

<!-- Log4j 日志系统（最常用） -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.22</version>
</dependency>

<!-- jackson -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.6.7</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.6.7</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.6.7</version>
</dependency>

6、创建springmvc的配置文件（上文）

7、在web.xml中启动springmvc的DispatcherServlet前置控制器，即拦截所有或者自定义后缀类型的请求，转发到对应的controller

<!--使用Spring MVC,配置DispatcherServlet是第一步。DispatcherServlet是一个Servlet,,所以可以配置多个DispatcherServlet-->
<!--DispatcherServlet是前置控制器，配置在web.xml文件中的。拦截匹配的请求，Servlet拦截匹配规则要自已定义，把拦截下来的请求，依据某某规则分发到目标Controller(我们写的Action)来处理。-->
<servlet>
  <servlet-name>DispatcherServlet</servlet-name><!--在DispatcherServlet的初始化过程中，框架会在web应用的 WEB-INF文件夹下寻找名为[servlet-name]-servlet.xml 的配置文件，生成文件中定义的bean。-->
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <!--指明了配置文件的文件名，不使用默认配置文件名，而使用dispatcher-servlet.xml配置文件。-->
  <init-param>
    <param-name>contextConfigLocation</param-name>
    <!--其中<param-value>**.xml</param-value> 这里可以使用多种写法-->
    <!--1、不写,使用默认值:/WEB-INF/<servlet-name>-servlet.xml-->
    <!--2、<param-value>/WEB-INF/classes/dispatcher-servlet.xml</param-value>-->
    <!--3、<param-value>classpath*:dispatcher-servlet.xml</param-value>-->
    <!--4、多个值用逗号分隔-->
    <param-value>WEB-INF/conf/springmvc/spring-mvc.xml</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup><!--是启动顺序，让这个Servlet随Servletp容器一起启动。-->
</servlet>
<servlet-mapping>
  <!--这个Servlet的名字是dispatcher，可以有多个DispatcherServlet，是通过名字来区分的。每一个DispatcherServlet有自己的WebApplicationContext上下文对象。同时保存的ServletContext中和Request对象中.-->
  <!--ApplicationContext是Spring的核心，Context我们通常解释为上下文环境，我想用“容器”来表述它更容易理解一些，ApplicationContext则是“应用的容器”了:P，Spring把Bean放在这个容器中，在需要的时候，用getBean方法取出-->
  <servlet-name>DispatcherServlet</servlet-name>
  <!--Servlet拦截匹配规则可以自已定义，当映射为@RequestMapping("/user/add")时，为例,拦截哪种URL合适？-->
  <!--1、拦截*.do、*.htm， 例如：/user/add.do,这是最传统的方式，最简单也最实用。不会导致静态文件（jpg,js,css）被拦截。-->
  <!--2、拦截/，例如：/user/add,可以实现现在很流行的REST风格。很多互联网类型的应用很喜欢这种风格的URL。弊端：会导致静态文件（jpg,js,css）被拦截后不能正常显示。 -->
  <url-pattern>/</url-pattern> <!--会拦截URL中带“/”的请求。-->
</servlet-mapping>

8、完成springmvc的配置，接下来我们来吧velocity模板引擎搭进我们的项目中吧

9、增加velocity的依赖

<!-- VELOCITY模板引擎依赖开始 -->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity</artifactId>
    <version>1.7</version>
</dependency>
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-tools</artifactId>
    <version>2.0</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>4.1.3.RELEASE</version>
</dependency>
<!-- VELOCITY模板引擎依赖结束 -->

10、创建velocity的配置文件velocity.properties

#设置字符集
#encoding
input.encoding  =UTF-8
output.encoding=UTF-8
contentType=text/html;charset=UTF-8

#autoreload when vm changed
file.resource.loader.cache=false
file.resource.loader.modificationCheckInterval  =1
velocimacro.library.autoreload=false

11、在springmvc的配置文件用以下视图解析覆盖原来的jsp的试图解析配置

<!-- velocity环境配置 -->
<bean id="velocityConfig" class="org.springframework.web.servlet.view.velocity.VelocityConfigurer">
    <!-- velocity配置文件路径  或者直接用velocityProperties属性 -->
    <property name="configLocation" value="classpath:velocity.properties"/>
    <!-- velocity模板路径 -->
    <property name="resourceLoaderPath" value="/WEB-INF/views/"/>
</bean>
<!-- velocity视图解析器 -->
<bean id="velocityViewResolver" class="org.springframework.web.servlet.view.velocity.VelocityLayoutViewResolver">
    <property name="order" value="0"/>
    <property name="contentType" value="text/html;charset=UTF-8"/>
    <property name="cache" value="true"/>
    <property name="suffix" value=".vm"/>
    <property name="layoutUrl" value="layout/layout.vm"/>
    <property name="exposeSpringMacroHelpers" value="true" /><!--是否使用spring对宏定义的支持-->
    <property name="exposeSessionAttributes" value="true" /><!--是否开放request属性-->
    <property name="requestContextAttribute" value="request"/><!--request属性引用名称-->
    <property name="dateToolAttribute" value="dateTool"/>
    <property name="numberToolAttribute" value="numberTool"/>
</bean>

12、增加velocity的布局文件layout.vm，注意：上诉配置中的layoutUrl是基于resourceLoaderPath的路径，即layoutUrl中配置的layout/layout.vm路径实际为/WEB-INF/views/layout/layout.vm。

13、接下来就可以直接在controller中返回视图啦，注意创建的页面的后缀为vm

14、接下来我们来配置velocity的工具箱，首先创建toolbox.xml文件，即工具箱配置文件

<?xml version="1.0" encoding="UTF-8"?>
<toolbox>
    <tool>
        <key>dateTools</key>
        <scope>application</scope>
        <class>org.apache.velocity.tools.generic.DateTool</class>
        <parameter name="format" value="yyyy-MM-dd HH:mm:ss"/>
    </tool>
    <tool>
        <key>link</key>
        <scope>request</scope>
        <class>org.apache.velocity.tools.view.tools.LinkTool</class>
    </tool>
    <tool>
        <key>messages</key>
        <scope>request</scope>
        <class>org.apache.velocity.tools.struts.StrutsLinkTool</class>
    </tool>
    <tool>
        <key>stringUtils</key>
        <scope>request</scope>
        <class>org.apache.velocity.util.StringUtils</class>
    </tool>
    <tool>
        <key>math</key>
        <scope>application</scope>
        <class>org.apache.velocity.tools.generic.MathTool</class>
    </tool>
    <tool>
        <key>esc</key>
        <scope>request</scope>
        <class>org.apache.velocity.tools.generic.EscapeTool</class>
    </tool>
    <tool>
        <key>params</key>
        <scope>request</scope>
        <class>org.apache.velocity.tools.view.tools.ParameterParser</class>
    </tool>
</toolbox>

15、在springmvc的视图解析器velocityViewResolver中增加如下配置：

<property name="toolboxConfigLocation" value="/WEB-INF/conf/velocity/toolbox.xml"/>

即指定工具箱配置文件的位置

16、接下来就可以使用了，例如要使用toolbox中的dateTools来格式化日期，如下：

$!{dateTools.format("yyyy-MM-dd HH:mm:ss",$!{bean.gmtCreate})}

17、MyBatis

<!--mybatis-spring适配器 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
<!--Spring java数据库访问包，在本例中主要用于提供数据源 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.2.7.RELEASE</version>
</dependency>
<!--mysql数据库驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.38</version>
</dependency>
<!--log4j日志包 -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.6.1</version>
</dependency>
<!-- mybatis ORM框架 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.1</version>
</dependency>
<!-- JUnit单元测试工具 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
</dependency>
<!--c3p0 连接池 -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>

接下来增加mybatis的配置文件

R_Scholar
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java velocity详解_[velocity] velocity详解
weixin_32816821的博客
02-27 4446
(1)为什么要使用模版语言？在服务器端可以使用Velocity处理模板和生成的动态内容(HTML、XML等)。这和JSP技术的目标非常接近。但是，JSP模型可以毫无阻碍地访问底层的ServletAPI和Java编程语言。它基本上是一种在很大程度上开放的访问模型。而作为一种完全自包含的模板引擎和脚本解释器，Velocity拥有完全封闭的模型。任何针对系统和/或Java编程语言的访问都必须明确地启...
springmvc+mybatis+velocity配置
jianghuihong2012的专栏
12-21 763
首先说明，在java的web框架中，最难的一个步骤，就是设置配置文件，配置文件复杂繁多，而且特别容易配置错误，经过不懈努力，一步步配置好了。 1、文件目录 本工程是eclipse+maven的webapp工程 2、webx.xml配置<?xml version="1.0" encoding="UTF-8"?> <web-app version="3.0" xmlns="http://jav
Android Volley完全解析(一)，初识Volley的基本用法
热门推荐
郭霖的专栏
04-10 36万+
我们平时在开发Android应用的时候不可避免地都需要用到网络技术，而多数情况下应用程序都会使用HTTP协议来发送和接收网络数据。Android系统中主要提供了两种方式来进行HTTP通信，HttpURLConnection和HttpClient，几乎在任何项目的代码中我们都能看到这两个类的身影，使用率非常高。Android开发团队也是意识到了有必要将HTTP的通信操作再进行简单化，于是在2013年Google I/O大会上推出了一个新的网络通信框架——Volley。Volley可是说是把AsyncHttpC
Velocity
hzzwh的专栏
11-16 833
    Velocity是一个基于java的模板引擎（template engine）。它允许任何人仅仅简单的使用模板语言（template language）来引用由java代码定义的对象。 当Velocity应用于web开发时，界面设计人员可以和java程序开发人员同步开发一个遵循MVC架构的web站点，也就是说，页面设计人员可以只关注页面的显示效果，而由java程序开发人员关注业务逻辑编码。
VOL框架学习（一）从零开始搭建项目
qq_38769403的博客
09-28 1万+
主要资料 demo地址：http://www.volcore.xyz 帐号：admin666；密码：123456（本地超级管理员帐号：admin；密码：123456) github地址：https://github.com/cq-panda/vue.netcore gitee码云：https://gitee.com/x_discoverer/Vue.NetCore 开发文档：http://v2.volcore.xyz/document/guide 操作步骤 1.下载代码 在gitee上下
Java基于Spring+SpringMVC+MyBatis实现的学生信息管理系统源码.zip
05-04
Java基于Spring+SpringMVC+MyBatis实现的学生信息管理系统源码，SSM+Vue的学生管理系统。 Java基于Spring+SpringMVC+MyBatis实现的学生信息管理系统源码，SSM+Vue的学生管理系统。 Java基于Spring+SpringMVC+...
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
本资源对应博文：http://blog.csdn.net/zhshulin/article/details/37956105，可以通过博文进行学习，不建议下载完整源码，博文有详细教程，以及代码。
SpringBoot+SpringMvc+Spring+MyBatis项目全程实战开发(附完整源码)
06-18
全程实战讲解，附源码 数据库脚本和项目...核心技术：SpringBoot+SpringMvc+Spring+MyBatis+Mysql+Thymeleaf+Jquery+Ajax+HTML+CSS，使用Maven完成项目的构建！ 项目前台点餐系统部分截图： 项目后台管理系统部分截图：
基于Spring+SpringMVC+Mybatis架构的博客系统.zip
04-29
基于Spring+SpringMVC+Mybatis架构的博客系统：博客管理、图表数据、日志分析、访问记录、图库管理、资源管理、友链通知等。良好的页面预加载，无限滚动加载，文章置顶，博主推荐等。提供 用户端+管理端 的整套系统...
spring+springmvc+mybatis
10-19
spring+springmvc+mybatis 适合练手，但是jdk版本不要太高，不然运行容易出现版本的问题
java velocity模板用法（替换、循环、if判断）
Z丶royAl的博客
03-26 1万+
一、.vm模板文件，例如一个名为test.vm的模板文件 ${name} #foreach($nameObj in $inputNewNames) alert($nameObj); #end var obj = {//对象加逗号，用$velocityCount判断是否是最后一个 #foreach($nameObj in $inputNewNames) "$nameObj":$n...
初识模板框架【Velocity】
GreekJ的专栏
11-05 2721
因最近项目中涉及到javabean 2 XML的转换，比较多，但是又不涉及具体的业务逻辑，请求系统与目标系统间进行数据透传，两个系统间的报文字段都不一致，需要进行映射转换，所以考虑再三，xml2bean选择了xpath实现，然后再把bean转换为对应的xml，此过程考虑几个不同的模板引擎：FreeMarker、Thymeleaf、Enjoy、Velocity，对比了几个的优缺点之后，选择了Vel...
代码生成框架Velocity
chszs的专栏
03-22 7847
代码生成框架VelocityVelocity是一个基于Java的模板引擎，用户可以使用模板语言VTL来引用由Java代码定义的对象。Velocity通常可以作为动态生成页面而广泛使用，还是一种功能强大的代码生成工具。Velocity模板类似于JSP文件，当客户端发送请求后，Velocity引擎江根据模板产生动态地页面。如果要使用Velocity生成动态页面，需要扩展VelocityServle
Velocity Java 模板引擎 基本语法
程序员小奎的博客
10-08 2万+
学习一个新技术 我们首先要了解 这个东西是什么？能做什么？怎么用？在更深层次了解就是 原理是什么？ 我们就先来执行第一步 Velocity 是什么。访问velocity官网进行快速了解。http://velocity.apache.org/ 大致内容如下： Velocity是一个基于Java的模板引擎。它允许任何人使用简单但功能强大的模板语言来引用Java代码中定义的对象。 当Veloc...
SpringBoot整合velocity
程序员的专栏
03-07 4486
SpringBoot整合velocity
spring及springMVC及web.xml通配
zfl_1994的博客
08-22 293
框架搭建
使用Velocity的tool出现的问题
坐忘峰
01-21 1万+
开发使用的是SpringMVC+Velocity的架构，要使用Velocity的tools，在整合时代码如下：        class="org.springframework.web.servlet.view.velocity.VelocityViewResolver"> text/html;charset=UTF-8 dateTool    
ssm使用velocity模板语言
weixin_30887919的博客
12-09 185
1、在pom.xml里添加velocity模板语言支持的依赖 <!-- velocity模板语言支持包 --> <dependency> <groupId>org.apache.velocity</groupId> <artifactId>velocity</artifactId> ...
怎么快速高效学习spring+springmvc+vue+mybatis？
最新发布
05-03
学习Spring、Spring MVC、Vue和MyBatis需要一定的时间和精力，以下是我推荐的一些学习方法和资源： 1. 了解基础概念：在开始学习之前，你需要对这些技术有一定的了解。可以通过阅读相关的书籍或者网上的文章来学习基础概念。 2. 学习官方文档：官方文档是最权威的学习资源，可以帮助你快速掌握这些技术的知识点。 3. 做项目实战：做项目是最好的学习方法之一，可以帮助你将理论知识应用到实践中，提高自己的编码能力。 4. 参加培训课程：如果你想快速掌握这些技术，可以参加相关的培训课程，通过专业老师的指导来学习。 以下是我推荐的一些学习资源： 1. Spring官方文档：https://spring.io/docs 2. Spring MVC官方文档：https://docs.spring.io/spring/docs/5.3.8/spring-framework-reference/web.html 3. Vue官方文档：https://cn.vuejs.org/v2/guide/ 4. MyBatis官方文档：https://mybatis.org/mybatis-3/zh/index.html 5. 慕课网：https://www.imooc.com/ 6. 极客时间：https://time.geekbang.org/ 希望这些资源能够帮助你快速高效地学习Spring、Spring MVC、Vue和MyBatis。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值