SSM整合

最新推荐文章于 2022-12-20 14:18:34 发布
最新推荐文章于 2022-12-20 14:18:34 发布
阅读量92 收藏
点赞数
分类专栏： SSM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/amspony/article/details/117631147
版权

回顾

文件上传
	前端三要素
		文件上传表单项为 file类型且有name属性
		表单请求方式 post
		表单enctype属性："multipart/form-data" 多部分表单提交
	后台
		导入fileupload和io依赖
		项目只需要配置multipartResovler(名字固定)
		在方法参数中声明MultipartFile类型参数,名字和input的标签的name属性保持一致.
		在方法中对文件进行操作
请求相关注解
	@RequestParam
		当请求过来的数据和方法中参数不一致的时候,可以使用此注解形成对应关系.还可以设置默认值,还可以将页面上的同名参数封装成list
		value	指定参数名
		defaultValue 设置默认值
	了解@RequestHeader 获取请求头信息
	了解@CookieValue 获取指定cookie的值
获得原生ServletAPI(request,response,session)
	方式1:方法上声明参数
	方式2:注入
静态资源放行
	方式1:开启静态资源servlet支持
		<mvc:default-servlet-handler/>
	方式2:映射静态资源路径
		<mvc:resources mapping="/img/**" location="/img/"/>
		<mvc:resources mapping="/css/**" location="/css/"/>
	方式3:修改前端控制器的匹配路径 常用*.do	
springMVC响应(方法的返回值)
	string:
		1.默认转发
		2.使用forward关键字完成转发,可以使用map modelmap model往request域中存放数据
		3.使用redirect关键字完成重定向
			站外资源:写路径
			站内资源:内部路径,和转发的路径写法一样
	void:使用原生的api完成响应操作
	ModelAndView:
    	可以设置数据
    	可以设置跳转的视图
	@SessionAttributes:作用在类上,将数据转存到session中
ajax:
	使用下面这两个注解务必导入jackson依赖.
	@RequestBody:将json数据封装成指定的javabean或者map
	@ResponseBody:将方法的返回值转成json返回给浏览器
Restful
	通过请求路径+请求方式来简化路径编写
    - 查询操作 发送get请求    /user/2/tom
    - 删除操作 发送delete请求  /user/2
    - 保存操作 发送post请求   /user
    - 更新操作 发送put请求   /user
	@PathVariable 获取路径上的/user/{id}的id值,赋值给方法的参数
	@RestController 等价于 @ResponseBody+@Controller 
全局异常处理器
	异常最终抛给DispatcherServlet,在web层也抛
	web方式
		通过error-page标签配置404和500状态码跳转的路径
	springmvc方式
        xml方式
            编写异常处理器类实现HandlerExceptionResolver
            配置异常处理器交给IOC容器
        注解方式
        	编写一个类,添加@ControllerAdvice
        	在类中编写方法,在方法上通过@ExceptionHandler的value属性声明处理哪些异常

内容介绍

  1. 拦截器.类似过滤器
  2. SSM整合(掌握)
    • spring + springMVC + Mybatis

一 SpringMVC的拦截器

1 介绍

SpringMVC的拦截器类似于web阶段所学的filter过滤器，对处理器(方法)进行前置 和后置 拦截操作。

filter可以过滤拦截web工程中任意请求,springmvc中拦截器只能拦截当前框架环境中的方法.

2 快速入门

步骤分析:

  1. 导入模块
  2. 模块中有一个Controller,提供了三个方法
    • 名字 – 路径
    • test1 – test1
    • test2 – test2
    • test3 – test/test3
  3. 编写一个拦截器,实现一个接口 HandlerInterceptor
  4. 选择需要重写方法(3个方法)
  5. 在springmvc.xml中配置拦截器的拦截规则
    • 对那些路径进行拦截
      • 对所有的路径进行拦截
    • 忽略拦截规则中一些方法
      • 放行 test2
  6. 测试

代码实现:

拦截器

public class HelloInterceptor1 implements HandlerInterceptor {
    @Override
    //目标方法执行之前的操作
    /*
        返回值:是否放行
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("1 -- preHandle执行了");
        return true;
    }

    @Override
    //目标方法执行之后的操作,视图渲染之前
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("1 -- postHandle 执行了");
    }

    @Override
    //视图渲染之后的操作
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("1 -- afterCompletion 执行了");
    }
}

controller

@Controller
@RequestMapping("demo")
public class DemoController {
    @RequestMapping(value="test1",method = RequestMethod.GET)
    public String test1(){
        System.out.println("test1 方法执行了");
        return "success";
    }

    @RequestMapping(value="test2",method = RequestMethod.GET)
    public String test2(){
        System.out.println("test2 方法执行了");
        return "success";
    }

    @RequestMapping(value="test/test3",method = RequestMethod.GET)
    public String test3(){
        System.out.println("test3 方法执行了");
        return "success";
    }
}

springmvc.xml

<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--
			mapping标签的path配置对那些路径进行拦截,可以出现多次
               支持通配符 *
                   /demo/*  只拦截demo下的一层路径 例如:/demo/test1和/demo/test2,但是不拦截/demo/test/test3
                   /demo/** 拦截demo下的所有路径 例如:/demo/test1 , /demo/test2,/demo/test/test3
            exclude-mapping标签的path用来配置上面拦截的基础上放行那些路径,可以出现多次
        -->
        <mvc:mapping path="/demo/**"/>
        <mvc:exclude-mapping path="/demo/test2"/>
        <!--配置拦截器-->
        <bean class="com.itheima.web.interceptor.HelloInterceptor1"/>
    </mvc:interceptor>
</mvc:interceptors>

3 拦截器链

多个拦截器对我们同一个controller进行拦截,这些拦截器就是拦截器链,他们的执行顺序是由在xml中的顺序决定的.

<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/demo/**"/>
        <mvc:exclude-mapping path="/demo/test2"/>
        <bean class="com.itheima.web.interceptor.HelloInterceptor1"/>
    </mvc:interceptor>

    <mvc:interceptor>
        <mvc:mapping path="/demo/test1"/>
        <bean class="com.itheima.web.interceptor.HelloInterceptor2"/>
    </mvc:interceptor>
</mvc:interceptors>

4 案例:简易权限拦截器

需求

用户没有登录的情况下，不能访问用户中心，点击用户中心连接会拦截并跳转到登录页面 ; 只能用户登录后才可以访问用户中心页面。

说明:

  1. 在index.jsp上有两个连接
    • /springmvc/user/toLogin 跳转到登陆页面
    • /springmvc/user/homeIndex 跳转到用户中心页面
  2. 在UserController中提供3个方法
    • toLogin 跳转到登录页
    • homeIndex 跳转到用户中心页面
    • login 登陆操作

步骤分析

  • 编写一个拦截器 LoginPermissionInterceptor
    • 只需要重写preHandler方法
      • 判断session中有否用用户
        • 若有,放行
        • 若无,设置错误信息,转发到login.jsp
  • 在springmvc.xml中配置拦截器
    • 拦截用户下的所有方法
    • 放行和登陆相关的方法
  • 测试

代码实现

LoginInterceptor

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        //判断用户是否登陆,若登陆则放行;若没有登陆就跳转到登录页
        Object loginUser = request.getSession().getAttribute("loginUser");
        if (null == loginUser) {
            //没有登陆
            request.setAttribute("msg","请先登录");
            request.getRequestDispatcher("/WEB-INF/pages/login.jsp").forward(request,response);
            return false;
        }
        return true;
    }
}

LoginInterceptor拦截器配置

       <!--以下代码放在springmvc.xml中mvc:interceptors标签下-->
		<mvc:interceptor>
            <mvc:mapping path="/user/**"/>
            <mvc:exclude-mapping path="/user/login"/>
            <mvc:exclude-mapping path="/user/toLogin"/>
            <bean class="com.itheima.web.interceptor.LoginInterceptor"/>
        </mvc:interceptor>

二 SSM框架整合

1 需求

使用ssm框架完成对account表的增删改查操作。

注意:事务

2 步骤分析

  1. 新建web模块ssm_account
    • 导入依赖
      • web:servlet jsp jstl spring-webmvc
      • service:spring-jdbc aspectjweaver
      • dao:驱动 druid mybatis
      • 单元测试
      • 日志(稍后)
      • spring整合mybatis的包:mybatis-spring
    • 导入配置文件
      • db.properties
      • 日志配置
  2. 创建Account
  3. 保证dao层独立运行
  4. 保证service独立运行
  5. 整合service和dao
  6. 保证web层独立运行
  7. 整合service和web
  8. 添加事务控制
  9. 添加日志

三 SSM整合代码实现

0 最终pom

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

<dependencies>
   <dependency> 
      <groupId>javax.servlet</groupId>  
      <artifactId>javax.servlet-api</artifactId>  
      <version>3.1.0</version>  
      <scope>provided</scope> 
    </dependency>  
    <dependency> 
      <groupId>javax.servlet.jsp</groupId>  
      <artifactId>javax.servlet.jsp-api</artifactId>  
      <version>2.3.3</version>  
      <scope>provided</scope> 
    </dependency>
    <dependency>
        <groupId>jstl</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.5.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.1.5.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.2</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.32</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.9</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.1</version>
    </dependency>

    <!--测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.1.5.RELEASE</version>
    </dependency>

    <!--日志-->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.21</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.12</version>
    </dependency>

    <!--spring整合mybatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.2</version>
    </dependency>
</dependencies>

1 保证dao层独立运行

  1. 创建Account
  2. 提供AccountMapper及其映射文件
  3. 提供mybatis的核心配置文件
  4. 测试
public class Account {
    private Integer id;
    private String name;
    private Integer money;
}

public interface AccountMapper {
    List<Account> findAll();
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.AccountMapper">
    <select id="findAll" resultType="account">
        select * from account
    </select>
</mapper>

核心配置文件不用敲

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--别名配置-->
    <typeAliases>
        <package name="com.itheima.domain"/>
    </typeAliases>

    <!--环境配置-->
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///springdb"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>

    <!--映射文件配置-->
    <mappers>
        <package name="com.itheima.dao"/>
    </mappers>
</configuration>

测试代码一定不要敲

public class TestDao {

    @Test
    public void testDao() throws IOException {
        //加载配置文件
        InputStream is = Resources.getResourceAsStream("mybatis.xml");

        //创建SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);

        //获取session
        SqlSession sqlSession = factory.openSession();

        //获取dao
        AccountMapper accountMapper = sqlSession.getMapper(AccountMapper.class);

        //调用dao中的方法
        List<Account> list = accountMapper.findAll();
        System.out.println(list);

        //提交事务和释放资源
        sqlSession.commit();
        sqlSession.close();
    }
}

2 保证service独立运行

  1. 编写AccountService及其实现类
  2. 添加注解 @Service
  3. 编写applicationContext.xml
    • 开启组件扫描
  4. 测试
@Service
public class AccountServiceImpl implements AccountService {
    @Override
    public List<Account> findAll() {
        System.out.println("service执行了");
        return null;
    }
}

<?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:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--组件扫描-->
    <context:component-scan base-package="com.itheima"/>

</beans>

@ContextConfiguration("classpath:applicationContext.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class TestService {

    @Autowired
    AccountService accountService;

    @Test
    public void testService(){
        System.out.println(accountService.findAll());
    }
}

3 整合service和dao

spring整合其他框架 说白了就是找到要整合框架中的单实例对象,将这些对象交给spring管理即可

mybatis中哪些对象是我们需要单实例呢?

  • 连接池
  • SqlSessionFactory对象
  • 每个Dao的代理对象
  1. 导入依赖 mybatis-spring.xxx.jar
  2. 在spring配置文件中
    • 加载db.properties
    • 配置数据源
    • SqlSessionFactory对象 (SqlSessionFactoryBean类)
      • 注入数据源
      • 配置domain的别名
    • 每个dao的代理对象(MapperScannerConfigurer)
      • 注入dao包的位置
  3. 在AccountServiceImpl中注入mapper对象
  4. 再次测试service
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.2</version>
</dependency>

    <!--加载配置文件-->
    <context:property-placeholder location="classpath:db.properties"/>

    <!--配置数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--整合mbyatis-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"/>

        <!--配置别名-->
        <property name="typeAliasesPackage" value="com.itheima.domain"/>
    </bean>

    <!--扫描指定包及其子包下的所有接口,产生代理对象放入spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--配置需要扫描的包-->
        <property name="basePackage" value="com.itheima.dao"/>
    </bean>
</beans>

4 保证web层独立运行

  1. 创建AccountController
  2. 编写index.jsp,在index.jsp上新建一个连接,指向查询所有的操作
  3. 在web-inf/pages/account下编写account-list.jsp,在jsp中展示所有的账户
  4. 编写springmvc.xml
    • 扫描所有的controller
    • mvc注解支持
    • 视图解析器
    • 静态资源放行
  5. 在web.xml中编写前端控制器和字符编码过滤器
@Controller
@RequestMapping("account")
public class AccountController {

    @RequestMapping("list")
    public String findAll(){
        System.out.println("ctrl中方法执行了");
        return "account/account-list";
    }
}


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <table align="center" border="1" width="40%">
        <tr>
            <th>id</th>
            <th>姓名</th>
            <th>余额</th>
        </tr>
        <c:forEach items="${list}" var="account">
            <tr align="center">
                <td>${account.id}</td>
                <td>${account.name}</td>
                <td>${account.money}</td>
            </tr>
        </c:forEach>
    </table>
</body>
</html>

springmvc.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: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.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!--开启组件扫描-->
    <context:component-scan base-package="com.itheima.web"/>
    <!--开启mvc注解支持-->
    <mvc:annotation-driven/>
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--静态资源放行-->
    <mvc:default-servlet-handler/>
</beans>

web.xml

	<!--前端控制器-->
	<servlet>
		<servlet-name>DispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:springmvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>DispatcherServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

	<!--字符编码过滤器-->
	<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>

5 整合service和web

思考:

  1. spring的容器需要几个?
  2. spring的容器什么时候创建?
  3. 咱们怎么就知道项目启动了?
  4. 创建好的容器对象放到哪里,所有的controller(Servlet)可以访问到?
  5. 创建spring容器的需要指定什么?
  6. 配置文件路径应该在哪里指定?
  1. spring的容器需要几个?1个
  2. spring的容器什么时候创建?项目启动的时候创建
  3. 咱们怎么就知道项目启动了?可以使用ServletContextListener监听servletContext对象的创建.对象创建好了就代表项目启动成功了.
  4. 创建好的容器对象放到哪里,所有的controller(Servlet)可以访问到?ServletContext域中
  5. 创建spring容器的需要指定什么?spring的配置文件
  6. 配置文件路径应该在哪里指定?项目的初始化参数中

spring已经将上面的操作都封装好了,

  1. 导入一个依赖(spring-web)
  2. 在web.xml中通过context-param配置spring文件的位置
  3. 在web.xml配置一个spring提供好的监听器:ContextLoaderListener
  4. 在web(controller)中注入service即可

在项目启动的时候,加载web.xml中context-param中配置的spring配置文件,创建spring容器,将容器放入ServletContext域中

springmvc是spring的一部分,导入依赖的操作省略,只需要在web.xml中配置以下内容即可

<!--配置service和dao的配置文件的路径-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!--配置监听器-->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

6 添加事务控制

在applicationContext.xml中配置

  1. 事务管理器
  2. 通知的规则(什么方法使用那种隔离级别,传播行为,是否只读,超时时间等)
  3. aop配置(主要配置切入点,使用spring提供好的通知)
<!--配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"/>
</bean>

<!--事务运行规则-->
<tx:advice id="txAdvice">
    <tx:attributes>
        <tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

<!--aop配置-->
<aop:config>
    <aop:pointcut id="pc" expression="execution(* com.itheima.service.impl.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"/>
</aop:config>

7 添加日志

  1. 导入依赖:log4j,slf4j,slf4j和log4j整合依赖
  2. 复制log4j.properties文件到resources目录下
<!--日志-->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.21</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.12</version>
</dependency>

扩展阅读:java日志门面

  • https://www.cnblogs.com/xrq730/p/8619156.html

四 完成账户的保存操作

分析:

  1. 在AccountMapper中提供save(Account account),编写映射文件
  2. 在AccountService中提供save(Account account),在方法中调用dao的save方法
  3. 在AccountController提供save(Account account),在方法中调用service的save方法
  4. 在web-inf/pages/account提供一个添加账户的表单页面 account-add.jsp
  5. 在index.jsp上提供一个连接,能够转发到account-add.jsp

代码实现

AccountMapper和AccountService

void save(Account account);

映射文件

<insert id="save">
    insert into account values (null,#{name},#{money})
</insert>

AccountController

@RequestMapping("save")
public String save(Account account){
    accountService.save(account);
    return "redirect:/account/list";
}

@RequestMapping("saveUI")
public String saveUI(){
    return "account/account-add";
}

五 spring容器和springmvc容器关系

三大组件的初始化时机:

listener > filter > servlet

也就是spring容器先于springmvc容器初始化

了解下ContextLoaderListener做了那些操作.

不会起名字的程序猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSM框架整合实现数据库查询操作
qq_42457900的博客
05-21 6790
注：ssm框架整合jar包在网盘：链接：https://pan.baidu.com/s/1wcS0SNfXqNO5PszvZQeSWQ 密码：sm24 一、 1、先看结果： 2、文件位置： 二、看配置文件代码： （1）、applicationContext.xml (Spring配置文件） <?xml version="1.0" encoding="UTF-8"?&gt...
spring配置文件的编写
weixin_43880780的博客
11-14 444
<?xml version="1.0" encoding="UTF-8"?> <!--持久层配置 开始--> <!--引入数据库外部属性文件--> <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder&...
maven—分模块开发与设计
最新发布
daqi1983的博客
12-20 528
maven 分模块开发与设计
Maven高级应用（一）
weixin_56697114的博客
07-02 204
1、分模块开发与设计 1、工程模块与模块划分 1准备一个项目 能成功运行compile说明配置成功
SSM整合jar包
01-12
SSM整合指的是Spring、Spring MVC和MyBatis三个框架的集成，这在Java Web开发中是一种常见的技术栈。这三个框架的结合提供了强大的数据访问、业务逻辑处理和视图渲染能力，使得开发人员能够构建高效、模块化的Web...
ssm整合案例
04-10
SSM整合是Java web开发中常见的一种架构模式，它结合了Spring、Struts2和MyBatis三个开源框架，以实现高效、灵活的后端业务处理。本案例将深入探讨SSM整合的具体实现过程和涉及的技术点。 首先，Spring框架是整个...
SSM整合超市订单管理系统
11-28
SSM整合指的是Spring、SpringMVC和MyBatis三个开源框架的集成，它们共同构建了一个强大的Web应用程序开发模型。在本项目"SSM整合超市订单管理系统"中，这三者协同工作，为实现一个功能完善的超市订单管理平台提供了...
springboot SSM整合
12-22
**SpringBoot SSM整合** SpringBoot以其简洁的配置和快速的开发能力，逐渐成为Java Web开发的主流框架。然而在实际项目中，我们往往需要与传统的SSM（Spring、Struts、MyBatis）框架进行整合，以充分利用各自的优势...
ssm整合demo代码
01-23
在这个"ssm整合demo代码"中，我们可以学习到以下几个关键知识点： 1. **Spring框架**：Spring是Java企业级应用的核心框架，它提供了AOP（面向切面编程）、DI（依赖注入）以及对其他框架的集成支持。在SSM整合中，...
SSM整合案例
08-06
SSM整合，全称为Spring、SpringMVC和MyBatis的整合，是Java Web开发中常见的一种技术栈组合。Spring作为一个全面的轻量级应用框架，负责管理对象和依赖注入；SpringMVC作为Spring的Web模块，处理HTTP请求和响应；...
ssm 整合pagehelper
01-02
SSM整合PageHelper是Java开发中常见的一个技术组合，用于构建高效、易维护的Web应用。SSM是指Spring、SpringMVC和MyBatis三个框架的集成，而PageHelper是MyBatis的一个插件，主要用于简化数据库分页查询操作。 **...
ssm整合jar包
03-15
SSM整合指的是Spring、SpringMVC和MyBatis三个开源框架的集成，它们共同构建了一个强大的Java Web开发解决方案。在Java开发中，SSM整合能够帮助开发者高效地处理业务逻辑，实现模型-视图-控制器（MVC）的设计模式，...
SSM整合完成版源码，对应博客SSM整合
09-02
SSM整合是Java Web开发中常见的一种框架集成方式，它结合了Spring、Spring MVC和MyBatis三个强大的组件，以实现高效、灵活的后端服务开发。本项目提供了一个完整的SSM整合的源码示例，适用于学习和快速搭建基础功能...
ssm整合Jar包
10-02
SSM整合指的是Spring、Struts和MyBatis三个开源框架的集成，这是一套常见的Java Web开发技术栈。在这个"ssm整合Jar包"中，我们可以看到一系列与SSM整合相关的库，这些库分别承担了不同的职责。 1. **Hibernate-Core...
MyBatis mapperLocations、basePackage多数据路径配置
热门推荐
loongshawn的博客
02-16 5万+
MyBatis mapperLocations、basePackage配置多个目录的方法
Spring常见面试题总结
jike11231的博客
09-19 750
1、Spring是什么? Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。常见的配置方式有三种：基于XML的配置、基于注解的配置、基于Java的配置。 主要由以下几个模块组成： Spring Core：核心类库，提供IOC服务； Spring Context：提供框架式的Bean访问方式，以及企业级功能（JNDI、定时任务等）； Spring AOP：AOP服务； Spring DAO
spring整合mybatis的applicationContext.xml的基础配置
张鹏的博客
08-26 383
<?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:p="http://www.spri...
SSM实现最简单的登录验证
qq_25997041的博客
10-25 2648
SSM实现最简单的登录验证1.导入项目相关的jar包以上就是该项目所需要的一些jar包（可能会有些jar没有用到，jar包是我自己在网上找的，放在/WEB-INF/bin文件夹里面，就不需要导包了！）2.建立项目结构3.配置文件的配置db.propertiesjdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/
SpringMVC详解与SSM整合指南
SSM整合是指Spring、SpringMVC和MyBatis三个框架的集成，用于构建企业级的Java web应用。整合过程涉及以下步骤： 1. **添加依赖**：在项目pom.xml文件中引入Spring、SpringMVC和MyBatis的相关依赖库。 2. **配置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值