SSM框架整合步骤

最新推荐文章于 2023-05-28 14:34:54 发布
最新推荐文章于 2023-05-28 14:34:54 发布
阅读量2.7k 收藏 23
点赞数 6
分类专栏： 框架笔记 文章标签： JAVA SSM框架整合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33881464/article/details/87709571
版权

SSM框架整合步骤

一、搭建整合环境

1. 整合说明：SSM整合可以使用多种方式，本文章会选择XML + 注解的方式

2. 整合的思路

	1). 先搭建整合的环境
	2). 先把Spring的配置搭建完成
	3). 再使用Spring整合SpringMVC框架
	4). 最后使用Spring整合MyBatis框架

3. 创建数据库和表结构

	语句:
		create database ssm;
		use ssm;
		create table account(
			id int primary key auto_increment,
			name varchar(20),
			money double
		);

4. 创建maven的工程（会使用到工程的聚合和拆分的概念）

	1). 创建ssm_parent父工程（打包方式选择pom，必须的）
	2). 创建ssm_web子模块（打包方式是war包）
	3). 创建ssm_service子模块（打包方式是jar包）
	4). 创建ssm_dao子模块（打包方式是jar包）
	5). 创建ssm_domain子模块（打包方式是jar包）
	6). web依赖于service，service依赖于dao，dao依赖于domain
	7). 在ssm_parent的pom.xml文件中引入坐标依赖
		<properties>
			<spring.version>5.0.2.RELEASE</spring.version>
			<slf4j.version>1.6.6</slf4j.version>
			<log4j.version>1.2.12</log4j.version>
			<mysql.version>5.1.6</mysql.version>
			<mybatis.version>3.4.5</mybatis.version>
		</properties>
		<dependencies>
			<!-- spring -->
			<dependency>
				<groupId>org.aspectj</groupId>
				<artifactId>aspectjweaver</artifactId>
				<version>1.6.8</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-aop</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-context</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-web</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-webmvc</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-test</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-tx</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-jdbc</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>junit</groupId>
				<artifactId>junit</artifactId>
				<version>4.12</version>
				<scope>compile</scope>
			</dependency>
			<dependency>
				<groupId>mysql</groupId>
				<artifactId>mysql-connector-java</artifactId>
				<version>${mysql.version}</version>
			</dependency>
			<dependency>
				<groupId>javax.servlet</groupId>
				<artifactId>servlet-api</artifactId>
				<version>2.5</version>
				<scope>provided</scope>
			</dependency>
			<dependency>
				<groupId>javax.servlet.jsp</groupId>
				<artifactId>jsp-api</artifactId>
				<version>2.0</version>
				<scope>provided</scope>
			</dependency>
			<dependency>
				<groupId>jstl</groupId>
				<artifactId>jstl</artifactId>
				<version>1.2</version>
			</dependency>
			
			<!-- log start -->
			<dependency>
				<groupId>log4j</groupId>
				<artifactId>log4j</artifactId>
				<version>${log4j.version}</version>
			</dependency>
			<dependency>
				<groupId>org.slf4j</groupId>
				<artifactId>slf4j-api</artifactId>
				<version>${slf4j.version}</version>
			</dependency>
			<dependency>
				<groupId>org.slf4j</groupId>
				<artifactId>slf4j-log4j12</artifactId>
				<version>${slf4j.version}</version>
			</dependency>
			<!-- log end -->
			
			<dependency>
				<groupId>org.mybatis</groupId>
				<artifactId>mybatis</artifactId>
				<version>${mybatis.version}</version>
			</dependency>
			<dependency>
				<groupId>org.mybatis</groupId>
				<artifactId>mybatis-spring</artifactId>
				<version>1.3.0</version>
			</dependency>
			<dependency>
				<groupId>c3p0</groupId>
				<artifactId>c3p0</artifactId>
				<version>0.9.1.2</version>
				<type>jar</type>
				<scope>compile</scope>
			</dependency>
		</dependencies>
		<build>
			<finalName>ssm</finalName>
			<pluginManagement>
				<plugins>
					<plugin>
						<groupId>org.apache.maven.plugins</groupId>
						<artifactId>maven-compiler-plugin</artifactId>
						<version>3.2</version>
						<configuration>
							<source>1.8</source>
							<target>1.8</target>
							<encoding>UTF-8</encoding>
							<showWarnings>true</showWarnings>
						</configuration>
					</plugin>
				</plugins>
			</pluginManagement>
		</build>
	8).部署ssm_web的项目，只要把ssm_web项目加入到tomcat服务器中即可

5.编写实体类，在ssm_domain项目中编写

	package XXX.XXXXX.domain;
	import java.io.Serializable;
	public class Account implements Serializable{
		private static final long serialVersionUID = 7355810572012650248L;
		private Integer id;
		private String name;
		private Double money;
		public Integer getId() {
			return id;
		}
		public void setId(Integer id) {
			this.id = id;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public Double getMoney() {
			return money;
		}
		public void setMoney(Double money) {
			this.money = money;
		}
	}

6. 编写dao接口

	package XX.XXXXX.dao;
	import java.util.List;
	import XX.XXXXX.domain.Account;
	public interface AccountDao {
		public void saveAccount(Account account);
		public List<Account> findAll();
	}

7.编写service接口和实现类

	package XX.XXXXX.service;
	import java.util.List;
	import XX.XXXXX.domain.Account;
	public interface AccountService {
		public void saveAccount(Account account);
		public List<Account> findAll();
	}
	
	package XX.XXXXX.service.impl;
	import java.util.List;
	import org.springframework.stereotype.Service;
	import XX.XXXXX.dao.AccountDao;
	import XX.XXXXX.domain.Account;
	import XX.XXXXX.service.AccountService;
	@Service("accountService")
	public class AccountServiceImpl implements AccountService {
		private AccountDao account;
		public void saveAccount(Account account) {
		}
		public List<Account> findAll() {
			System.out.println("业务层：查询所有账户...");
			return null;
		}
	}

二、Spring框架代码的编写

1. 搭建和测试Spring的开发环境

1).在ssm_web项目中创建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: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.xsd
			http://www.springframework.org/schema/context
			http://www.springframework.org/schema/context/spring-context.xsd
			http://www.springframework.org/schema/aop
			http://www.springframework.org/schema/aop/spring-aop.xsd			
			http://www.springframework.org/schema/tx
			http://www.springframework.org/schema/tx/spring-tx.xsd">
			<!-- 开启注解扫描，要扫描的是service和dao层的注解，要忽略web层注解，因为web层让SpringMVC框架去管理 -->
			<context:component-scan base-package="XX.XXXXX">
				<!-- 配置要忽略的注解 -->
				<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
			</context:component-scan>
		</beans>

2).在ssm_web项目中编写测试方法，进行测试

		package XX.XXXXX.test;
		import org.junit.Test;
		import org.springframework.context.ApplicationContext;
		import org.springframework.context.support.ClassPathXmlApplicationContext;
		import XX.XXXXX.service.AccountService;
		public class ServiceTest {
			@Test
			public void run1() {
				ApplicationContext ac = new
				ClassPathXmlApplicationContext("classpath:applicationContext.xml");
				AccountService as = (AccountService) ac.getBean("accountService");
				as.findAll();
			}
		}

三、Spring整合SpringMVC框架

1.搭建和测试SpringMVC的开发环境

1). 在web.xml中配置DispatcherServlet前端控制器

		<!-- 配置前端控制器：服务器启动必须加载，需要加载springmvc.xml配置文件 -->
		<servlet>
			<servlet-name>dispatcherServlet</servlet-name>
			<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
			<!-- 配置初始化参数，创建完DispatcherServlet对象，加载springmvc.xml配置文件 -->
			<init-param>
				<param-name>contextConfigLocation</param-name>
				<param-value>classpath:springmvc.xml</param-value>
			</init-param>
			<!-- 服务器启动的时候，让DispatcherServlet对象创建 -->
			<load-on-startup>1</load-on-startup>
		</servlet>
		<servlet-mapping>
			<servlet-name>dispatcherServlet</servlet-name>
			<url-pattern>/</url-pattern>
		</servlet-mapping>

2). 在web.xml中配置DispatcherServlet过滤器解决中文乱码

		<!-- 配置解决中文乱码的过滤器 -->
		<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>

3).创建springmvc.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:context="http://www.springframework.org/schema/context"
			xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
			xsi:schemaLocation="
			http://www.springframework.org/schema/beans
			http://www.springframework.org/schema/beans/spring-beans.xsd
			http://www.springframework.org/schema/mvc
			http://www.springframework.org/schema/mvc/spring-mvc.xsd
			http://www.springframework.org/schema/context
			http://www.springframework.org/schema/context/spring-context.xsd">
			<!-- 扫描controller的注解，别的不扫描 -->
			<context:component-scan base-package="cn.itcast">
				<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
			</context:component-scan>
			<!-- 配置视图解析器 -->
			<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
				<!-- JSP文件所在的目录 -->
				<property name="prefix" value="/WEB-INF/pages/" />
				<!-- 文件的后缀名 -->
				<property name="suffix" value=".jsp" />
			</bean>
			<!-- 设置静态资源不过滤 -->
			<mvc:resources location="/css/" mapping="/css/**" />
			<mvc:resources location="/images/" mapping="/images/**" />
			<mvc:resources location="/js/" mapping="/js/**" />
			<!-- 开启对SpringMVC注解的支持 -->
			<mvc:annotation-driven />
		</beans>

4). 测试SpringMVC的框架搭建是否成功

		1. 编写index.jsp和list.jsp编写，超链接
			<a href="account/findAll">查询所有</a>
		2. 创建AccountController类，编写方法，进行测试
			package XX.XXXXX.controller;
			import org.springframework.stereotype.Controller;
			import org.springframework.web.bind.annotation.RequestMapping;
			@Controller
			@RequestMapping("/account")
			public class AccountController {
				/**
				* 查询所有的数据
				* @return
				*/
				@RequestMapping("/findAll")
				public String findAll() {
					System.out.println("表现层：查询所有账户...");
					return "list";
				}
			}

2. Spring整合SpringMVC的框架

1). 目的：在controller中能成功的调用service对象中的方法。

2). 在项目启动的时候，就去加载applicationContext.xml的配置文件，在web.xml中配置

		ContextLoaderListener监听器（该监听器只能加载WEB-INF目录下的applicationContext.xml的配置文件）。
		<!-- 配置Spring的监听器 -->
		<listener>
			<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
		</listener>
		<!-- 配置加载类路径的配置文件 -->
		<context-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:applicationContext.xml</param-value>
		</context-param>

3). 在controller中注入service对象，调用service对象的方法进行测试

		package XX.XXXXX.controller;
		import org.springframework.beans.factory.annotation.Autowired;
		import org.springframework.stereotype.Controller;
		import org.springframework.web.bind.annotation.RequestMapping;
		import XX.XXXXX.service.AccountService;
		@Controller
		@RequestMapping("/account")
		public class AccountController {
			@Autowired
			private AccountService accoutService;
			/**
			* 查询所有的数据
			* @return
			*/
			@RequestMapping("/findAll")
			public String findAll() {
				System.out.println("表现层：查询所有账户...");
				accoutService.findAll();
				return "list";
			}
		}

四、Spring整合MyBatis框架

1. 搭建和测试MyBatis的环境

1). 在web项目中编写SqlMapConfig.xml的配置文件，编写核心配置文件

		<?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>
			<environments default="mysql">
				<environment id="mysql">
					<transactionManager type="JDBC"/>
					<dataSource type="POOLED">
					<property name="driver" value="com.mysql.jdbc.Driver"/>
					<property name="url" value="jdbc:mysql:///数据库名称"/>
					<property name="username" value="用户名"/>
					<property name="password" value="密码"/>
					</dataSource>
				</environment>
			</environments>
			<!-- 使用的是注解 -->
			<mappers>
				<!-- <mapper class="XX.XXXXX.dao.AccountDao"/> -->
				<!-- 该包下所有的dao接口都可以使用 -->
				<package name="XX.XXXXX.dao"/>
			</mappers>
		</configuration>

2). 在AccountDao接口的方法上添加注解，编写SQL语句

		package XX.XXXXX.dao;
		import java.util.List;
		import org.apache.ibatis.annotations.Insert;
		import org.apache.ibatis.annotations.Select;
		import XX.XXXXX.domain.Account;
		public interface AccountDao {
			@Insert(value="insert into account (name,money) values (#{name},#{money})")
			public void saveAccount(Account account);
			@Select("select * from account")
			public List<Account> findAll();
		}

3).编写测试的方法

		package XX.XXXXX.test;
		import java.io.InputStream;
		import java.util.List;
		import org.apache.ibatis.io.Resources;
		import org.apache.ibatis.session.SqlSession;
		import org.apache.ibatis.session.SqlSessionFactory;
		import org.apache.ibatis.session.SqlSessionFactoryBuilder;
		import org.junit.Test;
		import XX.XXXXX.dao.AccountDao;
		import XX.XXXXX.domain.Account;
		public class Demo1 {
			@Test
			public void run1() throws Exception {
				// 加载配置文件
				InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
				// 创建工厂
				SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
				// 创建sqlSession对象
				SqlSession session = factory.openSession();
				// 获取代理对象
				AccountDao dao = session.getMapper(AccountDao.class);
				// 调用查询的方法
				List<Account> list = dao.findAll();
				for (Account account : list) {
					System.out.println(account);
				}
				// 释放资源
				session.close();
				inputStream.close();
			}
			@Test
			public void run2() throws Exception {
				Account account = new Account();
				account.setName("熊大");
				account.setMoney(400d);
				// 加载配置文件
				InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
				// 创建工厂
				SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
				// 创建sqlSession对象
				SqlSession session = factory.openSession();
				// 获取代理对象
				AccountDao dao = session.getMapper(AccountDao.class);
				dao.saveAccount(account);
				// 提交事务
				session.commit();
				// 释放资源
				session.close();
				inputStream.close();
			}
		}

2. Spring整合MyBatis框架

1). 目的：把SqlMapConfig.xml配置文件中的内容配置到applicationContext.xml配置文件中

		<!-- 配置C3P0的连接池对象 -->
		<bean id="dataSource"
			class="org.springframework.jdbc.datasource.DriverManagerDataSource">
			<property name="driverClassName" value="com.mysql.jdbc.Driver" />
			<property name="url" value="jdbc:mysql:///数据库名称"/>
			<property name="username" value="用户名"/>
			<property name="password" value="密码"/>
		</bean>
		<!-- 配置SqlSession的工厂 -->
		<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
			<property name="dataSource" ref="dataSource" />
		</bean>
		<!-- 配置扫描dao的包 -->
		<bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
			<property name="basePackage" value="XX.XXXXX.dao"/>
		</bean>

2). 在AccountDao接口中添加@Repository注解

3). 在service中注入dao对象，进行测试

4). 代码如下

		package XX.XXXXX.dao;
		import java.util.List;
		import org.apache.ibatis.annotations.Insert;
		import org.apache.ibatis.annotations.Select;
		import org.springframework.stereotype.Repository;
		import XX.XXXXX.domain.Account;
		@Repository
		public interface AccountDao {
			@Insert(value="insert into account (name,money) values (#{name},#{money})")
			public void saveAccount(Account account);
			@Select("select * from account")
			public List<Account> findAll();
		}
		
		package XX.XXXXX.service.impl;
		import java.util.List;
		import org.springframework.beans.factory.annotation.Autowired;
		import org.springframework.stereotype.Service;
		import XX.XXXXX.dao.AccountDao;
		import XX.XXXXX.domain.Account;
		import XX.XXXXX.service.AccountService;
		@Service("accountService")
		public class AccountServiceImpl implements AccountService {
			@Autowired
			private AccountDao accountDao;
				public void saveAccount(Account account) {
			}
			public List<Account> findAll() {
				System.out.println("业务层：查询所有账户...");
				return accountDao.findAll();
			}
		}
		
		package XX.XXXXX.controller;
		import java.util.List;
		import org.springframework.beans.factory.annotation.Autowired;
		import org.springframework.stereotype.Controller;
		import org.springframework.web.bind.annotation.RequestMapping;
		import XX.XXXXX.domain.Account;
		import XX.XXXXX.service.AccountService;
		@Controller
		@RequestMapping("/account")
		public class AccountController {
			@Autowired
			private AccountService accoutService;
			/**
			* 查询所有的数据
			* @return
			*/
			@RequestMapping("/findAll")
			public String findAll() {
				System.out.println("表现层：查询所有账户...");
				List<Account> list = accoutService.findAll();
				for (Account account : list) {
					System.out.println(account);
				}
				return "list";
			}
		}

5).配置Spring的声明式事务管理

		<tx:advice id="txAdvice" transaction-manager="transactionManager">
			<tx:attributes>
				<tx:method name="find*" read-only="true"/>
				<tx:method name="*" isolation="DEFAULT"/>
			</tx:attributes>
		</tx:advice>
		<aop:config>
			<aop:advisor advice-ref="txAdvice" pointcut="execution(public * XX.XXXXX.service..ServiceImpl.*(..))"/>
		</aop:config>

6). 测试保存帐户的方法

		@RequestMapping("/saveAccount") 
		public String saveAccount(Account account) {
			accoutService.saveAccount(account); 
			return "list"; 
		}
InMyHeart丿
关注
  • 6
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
SSM框架搭建步骤
03-30
里面有SSM框架搭建的全部过程。.....................
ssm整合步骤（自整理）
01-17
SSM（Spring+SpringMVC+MyBatis）是一种常见的Java Web开发框架整合模式，下面是SSM整合步骤的详细解释： 一、 导入包 在使用SSM框架之前，需要将相关的jar包导入到项目中。这里我们需要引入Spring、MyBatis和...
SSM集成详细步骤
Hang_666的博客
08-29 1045
SSM集成 1.SSM集成 = Spring+SpringMvc+Mybatis集成 2.框架集成核心，如果你的项目中，用到了Spring框架，那么其他框架主要 就是和Spring集成； 3.和Spring集成的核心思路： ①把当前框架的核心类，交给Spring管理（IOC） ②如果框架有事务，那么事务也要统一交给Spring管理（AOP） 4.步骤： ①Spring ②Spring+Mybatis+管理事务 ③Spring+Mybatis+SpringMVC 5.导包 Spring SpringM
SSM整合完整流程讲解
小鲁蛋的博客
08-04 7488
Spring的IOC容器创建先于SpringMVC的IOC容器SpringMVC扫描的是controller包，Spring要把其他的包扫描了，两个框架管理各自的组件了解监听器的作用，在服务器启动的时候加载Spring的配置文件Spring配置文件代替原来的 mybatis-config.xml其余的配置与单独使用时基本一致。...
SSM 整合详细步骤与配置（纯注解）
S mile0804的博客
05-18 4663
SSM（Spring + SpringMVC + MyBatis）是功能强大的开发框架，要使用它我们首先要学会如何将这三大模块整合起来，本篇文章我们就来实现 SSM 的整合！！！ 整合流程主要分为以下三块（第三部分主要是功能测试模块）：建立工程、Spring配置、Spring整合MyBatis配置、Spring整合SpringMVC配置等等。此外，我们还会通过实例演示以下整合之后框架的使用。
ssm框架集成步骤
weixin_45474361的博客
12-29 277
步骤 1. 导包 2. 配置spring核心配置文件 1. Jdbc.properties 2. dataSource 3. SqlSessionFactory 4. dao 5. service 6. 事务 3.controller层 4.springMvc核心配置文件的配置 1. 扫描包 2. 静态资源放行 3. 开启springMvc注解的支持 4. 视图解析器 5.web.xml 1....
SSM整合（超详细）
踏风彡的博客
10-04 2602
新建一个excepition包包下创建所需各个异常类记得继承相应的异常父类，原因：程序运行时遇到相应异常后可以不处理向上抛不继承坏处：以后每个方法都要加上这个类//继承RuntimeException类 public class TestExcepition extends RuntimeException {//区别自定义异常类的编码 public TestExcepition(Integer code) {} }
ssm框架的整合步骤及示例
最新发布
05-09
ssm框架的整合步骤及示例
基于maven的ssm框架整合的示例代码
08-28
【SSM框架整合详解】 SSM框架整合是Java Web开发中常见的技术组合，它由Spring、Spring MVC和MyBatis三个框架构成，提供了一个高效、灵活的开发环境。本篇文章将详细讲解基于Maven的SSM框架整合过程，旨在帮助...
ssm框架整合.docx
05-05
SSM框架整合指的是将Spring、Struts和MyBatis三个流行的Java开源框架集成在一起，用于构建高效、灵活的Web应用程序。这个过程涉及到多个步骤和组件的配置，包括依赖管理、项目结构设定、配置文件的编写等。下面我们...
SSM的整合
qq_36116242的博客
02-25 454
1. SSM整合的概述 什么是SSM整合 所谓SSM，即SpringMVC＋Spring +mybatis，标准的MVC设计模式，将整个系统划分为web、service层、DAO层。Spring MVC、spring、mybatis各司其职，在整个框架中有着不同的作用。 Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架，主要实现业务对象管理； Spring MVC框架，通过实现MVC模式将数据、业务与展现进行分离，主要负责 请求的转发和视图管理； My
Java框架——SSM整合
qq_51936245的博客
05-28 2087
AJAX初体验异步可理解为局部刷新，同步指需要按部就班地完成一整套流程AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。AJAX 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。Ajax 不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的Web应用程序的技术。在 2005 年，Google 通过其 Google Suggest 使 AJAX 变得流行起来。
SSM整合——简单的小项目实战
胜天半子祁同伟
04-05 2万+
SSM整合——简单的小项目实战
超详细SSM框架整合步骤
weixin_40351503的博客
02-24 1206
记录下SSM框架整合的步骤，以及框架中每个配置的作用。作为自己学习框架的学习总结。 一、配置Mybatis 1.数据库建表 使用的是Mysql数据库，建表语句如下： CREATE TABLE `flower` ( `id` int(10) NOT NULL AUTO_INCREMENT COMMENT '编号', `name` varchar(30) NOT ...
SSM项目集成的步骤
HelloBright的博客
03-29 1660
一、首先集成springMVC          a.导入相应的包          b.配置applicationContext-mvc.xml                    开启spring注解支持：mvc:annotation-driven />        配置注解扫描包：context:component-scan base-package="项目包名"/>   
SSM整合完整流程
分享思想，留下痕迹。
04-22 1727
✅作者简介：大家好，我是Leo，热爱Java后端开发者，一个想要与大家共同进步的男人😉😉 🍎个人主页：Leo的博客 💞当前专栏： SSM专栏 ✨特色专栏： MySQL学习 🥭本文内容：SSM整合完整流程 🖥️个人小站 ：个人博客，欢迎大家访问 📚个人知识库： 知识库，欢迎大家访问Spring 和 SpringMVC 本身就是同源的，作为 Spring 家族的一个框架，整合不整合都行，我们所说的不整合是指 Spring 和 SpringMVC 创建同一个 IOC 容器，整合是指 Spring 和
手把手教你 SSM 整合（非常非常非常非常非常详细）
热门推荐
越过山丘
10-29 3万+
SSM 整合   整合的思路是：    Spring管理持久层的mapper。    Spring管理业务层的service，service可以调用mapper接口。Spring进行事物控制。    Spring管理表现层的Handler，handler可以调用service接口。 工程创建    创建Maven工程–>create for archtype–>webapp 创建项目结...
SSM框架整合的具体流程（详解）
weixin_44209250的博客
03-14 977
如下是小伟对ssm框架整合的总结，如有不足请见谅。 第一步：引入依赖： &lt;!--规定spring依赖的版本--&gt; &lt;properties&gt; &lt;spring.version&gt;4.3.5.RELEASE&lt;/spring.version&gt; &lt;/properties&gt; &lt;dependencies&gt; ...
ssm框架整合的步骤
08-27
SSM框架整合的步骤一般包括以下几个步骤： 1. 搭建环境：安装并配置好Java、Maven和Tomcat等必要的软件和工具。 2. 创建项目：使用Maven创建一个新的空项目。 3. 导入依赖：在项目的pom.xml文件中添加Spring、Spring MVC和MyBatis等框架的依赖。 4. 配置web.xml：在项目的web.xml文件中配置DispatcherServlet和ContextLoaderListener等Servlet和监听器。 5. 配置Spring：创建Spring的配置文件（如applicationContext.xml）并进行必要的配置，如数据源、事务管理器、扫描包等。 6. 配置Spring MVC：创建Spring MVC的配置文件（如springmvc-servlet.xml）并进行必要的配置，如视图解析器、静态资源处理器、控制器映射等。 7. 配置MyBatis：创建MyBatis的配置文件（如mybatis-config.xml）并进行必要的配置，如数据源、Mapper扫描等。 8. 编写实体类和Mapper接口：根据业务需求，编写实体类和Mapper接口，并在Mapper接口中定义SQL语句。 9. 编写Service层和Controller层：根据业务需求，编写Service层和Controller层的代码，处理业务逻辑和请求响应。 10. 配置数据库连接信息：在项目的配置文件中配置数据库连接信息，包括数据库URL、用户名、密码等。 11. 部署项目：将项目打包成war包，并将war包部署到Tomcat等Web服务器上。 这些步骤是一个基本的概述，具体的步骤和配置可能会根据实际需求和个人习惯有所不同。在实际开发中，还需要根据具体情况进行一些额外的配置和调试工作。希望对你有所帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值