Maven搭建SpringMVC+Spring+MyBatis框架

最新推荐文章于 2024-06-28 14:54:26 发布
最新推荐文章于 2024-06-28 14:54:26 发布
阅读量390 收藏
点赞数
分类专栏： webservice-java 文章标签： spring spring mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxf0515/article/details/70595118
版权

一. 框架详情

Spring 是一个轻量级的Java开发框架，它是为了解决企业应用开发的复杂性而创建的。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

SpringMVC 属于SpringFrameWork的后续产品，分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。

MyBatis 是一个基于Java的持久层框架。MyBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）它消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java映射成数据库中的记录。

二. 创建Maven项目

1.项目结构如下

这里写图片描述

2. Maven引入需要的JAR包
    <properties>
<spring.version>3.2.8.RELEASE</spring.version>
<json-version>1.8.4</json-version>
<xml-version>1.4.7</xml-version>
<!-- mysql驱动版本号 -->
<mysql-driver.version>5.1.29</mysql-driver.version>
<mybatis.version>3.2.8</mybatis.version>
<slf4j.version>1.7.18</slf4j.version>
<log4j.version>1.2.17</log4j.version>
  </properties>

  <dependencies>
    <!-- 添加jstl依赖 -->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>javax</groupId>
      <artifactId>javaee-api</artifactId>
      <version>7.0</version>
    </dependency>
    <!-- 添加junit4依赖 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>
    <!-- 添加spring核心依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</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-oxm</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>org.springframework</groupId>
      <artifactId>spring-webmvc</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-context-support</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>

<!-- 添加mybatis依赖 -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>${mybatis.version}</version>
</dependency>
<!-- 添加mybatis/spring整合包依赖 -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>1.2.2</version>
</dependency>
<!-- 添加mysql驱动依赖 -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>${mysql-driver.version}</version>
</dependency>
<!-- 添加数据库连接池依赖 -->
<dependency>
  <groupId>commons-dbcp</groupId>
  <artifactId>commons-dbcp</artifactId>
  <version>1.2.2</version>
</dependency>
<dependency>
  <groupId>com.mchange</groupId>
  <artifactId>c3p0</artifactId>
  <version>0.9.2.1</version>
</dependency>
<!-- 添加fastjson -->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>1.1.41</version>
</dependency>
<!-- 添加日志相关jar包 -->
<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 -->
<!-- 映入JSON -->
<dependency>
  <groupId>org.codehaus.jackson</groupId>
  <artifactId>jackson-mapper-asl</artifactId>
  <version>1.9.13</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-core</artifactId>
  <version>2.8.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.8.0</version>
</dependency>
<dependency>
  <groupId>com.fasterxml.jackson.jaxrs</groupId>
  <artifactId>jackson-jaxrs-json-provider</artifactId>
  <version>2.4.1</version>
</dependency>
<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.3.1</version>
</dependency>
<dependency>
  <groupId>commons-io</groupId>
  <artifactId>commons-io</artifactId>
  <version>2.4</version>
</dependency>
<dependency>
  <groupId>commons-codec</groupId>
  <artifactId>commons-codec</artifactId>
  <version>1.9</version>
</dependency>

<dependency>
  <groupId>javax.ws.rs</groupId>
  <artifactId>jsr311-api</artifactId>
  <version>1.0</version>
</dependency>

<dependency>
  <groupId>commons-lang</groupId>
  <artifactId>commons-lang</artifactId>
  <version>2.6</version>
</dependency>

<dependency>
  <groupId>org.codehaus.groovy</groupId>
  <artifactId>groovy-all</artifactId>
  <version>2.2.2</version>
</dependency>
<dependency>
  <groupId>net.sf.json-lib</groupId>
  <artifactId>json-lib</artifactId>
  <version>2.4</version>
  <classifier>jdk15</classifier>
</dependency>

<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-lang3</artifactId>
  <version>3.0</version>
</dependency>

<dependency>
  <groupId>commons-httpclient</groupId>
  <artifactId>commons-httpclient</artifactId>
  <version>3.1</version>
</dependency>
<dependency>
  <groupId>org.apache.httpcomponents</groupId>
  <artifactId>httpclient</artifactId>
  <version>4.3.6</version>
</dependency>


  </dependencies>
  <build>
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-war-plugin</artifactId>
          <version>2.4</version>
          <configuration>
            <warSourceDirectory>src/main/webapp</warSourceDirectory>
            <warName>Spring4MVCRestServiceDemo</warName>
            <failOnMissingWebXml>false</failOnMissingWebXml>
          </configuration>
        </plugin>
      </plugins>
    </pluginManagement>
    <finalName>com.ttook.springmvc</finalName>
  </build>
3.创建model
创建一个model包并在其下创建一个Person.Java文件。
package com.ttook.springmvc;
public class Person {
    private static final long serialVersionUID = -3727979363425652597L;
private int uid;        
private String uname;       
private String usex;        
private int uage;   
private String uaddress;
public Person() {
    super();
}
    public Person(int uid, String uname, String usex, int uage, String uaddress) {
        this.uid = uid;
        this.uname = uname;
        this.usex = usex;
        this.uage = uage;
        this.uaddress = uaddress;
    }   
    public int getUid() {
        return uid;
    }       
    public void setUid(int uid) {
        this.uid = uid;
    }       
    public String getUname() {
        return uname;
    }       
    public void setUname(String uname) {
        this.uname = uname;
    }   
    public String getUsex() {
        return usex;
    }
    public void setUsex(String usex) {
        this.usex = usex;
    }
    public int getUage() {
        return uage;
    }
    public void setUage(int uage) {
        this.uage = uage;
    }
    public String getUaddress() {
        return uaddress;
    }
    public void setUaddress(String uaddress) {
        this.uaddress = uaddress;
    }
}
4.创建dao接口
创建一个包dao，并在其下创建一个PersonDao.java文件作为DAO接口。
    package com.ttook.springmvc.dao;
    import com.ttook.springmvc.Person;
    import org.springframework.stereotype.Repository;
    @Repository
    public interface PersonDao {
        public Person queryPersonById(int id) ;
    }
5.实现dao接口
在resource/mappering包下创建一个PersonMapper.xml文件作为上一步创建的DAO接口的实现。
<?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.ttook.springmvc.dao.PersonDao">
    <select id="queryPersonById" parameterType="java.lang.Integer" resultType="com.ttook.springmvc.Person">
        SELECT * FROM testTable
        WHERE uid = #{uid}
    </select>
</mapper>
6. 创建service接口
package com.ttook.springmvc.service;
import com.ttook.springmvc.Person;
import java.util.List;
public interface IPersonServices {
    public Person queryPersonById(int id);
    public List<Person> queryPersonAll(int id);
}
7. 实现service接口
package com.ttook.springmvc.service;
import com.ttook.springmvc.Person;
import com.ttook.springmvc.dao.PersonDao;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class IPersonServicesImpl implements IPersonServices {
    private static final Logger logger = Logger.getLogger(IPersonServicesImpl.class);
    @Autowired
    PersonDao personDao;
    public Person queryPersonById(int id) {
        logger.info("queryPersonById === " + id);
        Person person = personDao.queryPersonById(id);
        return person;
    }
    public List<Person> queryPersonAll(int id) {
        return null;
    }
}
8. 创建controller接口
package com.ttook.springmvc.controller;
import com.ttook.springmvc.Person;
import org.springframework.stereotype.Repository;
import org.springframework.web.bind.annotation.*;
import javax.ws.rs.core.MediaType;
@Repository
public interface IPersonController {
    @RequestMapping(value = "/hello", produces = "text/plain;charset=UTF-8")
    public @ResponseBody
    String hello();

@RequestMapping(value = "/say/{msg}", produces = "application/json;charset=UTF-8")
public @ResponseBody
String say(@PathVariable(value = "msg") String msg);

@RequestMapping(value = "/getPerson/{id:\\d+}", method = RequestMethod.GET, produces = "application/json;charset=UTF-8")
public @ResponseBody
String getPerson(@PathVariable("id") int id);

@RequestMapping(value = "/deletePerson/{id:\\d+}", method = RequestMethod.DELETE)
public @ResponseBody Object deletePerson(@PathVariable("id") int id) ;

/**
 * 推荐使用，这种可以解决绝大多数问题
 * @param person
 * @return
 */
@RequestMapping(value = "/addPerson", method = RequestMethod.POST, produces = {MediaType.APPLICATION_JSON,"application/json;charset=UTF-8"},
        consumes = {MediaType.APPLICATION_JSON,MediaType.APPLICATION_XML})
public String addPerson(Person person);

@RequestMapping(value = "/updatePerson", method = RequestMethod.PUT)
public @ResponseBody Object updatePerson(@RequestBody Person person);

}
9. 实现controller接口
package com.ttook.springmvc.controller;

import com.ttook.springmvc.Person;
import com.ttook.springmvc.service.IPersonServices;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.apache.log4j.Logger;
import javax.annotation.Resource;
@Controller
@RequestMapping("/test")
public class IPersonControllerImpl implements IPersonController {

    /** 日志实例 */
    private static final Logger logger = Logger.getLogger(IPersonControllerImpl.class);

    @Autowired
    IPersonServices iPersonServices;


    public @ResponseBody
    String hello() {
        logger.info("hello........");
        return "你好！hello";
    }

    public @ResponseBody
    String say(@PathVariable(value = "msg") String msg) {
        return "{\"msg\":\"you say:'" + msg + "'\"}";
    }

    public @ResponseBody
    String getPerson(@PathVariable("id") int id) {

        Person person=iPersonServices.queryPersonById(id);
        JSONObject jsonObject = JSONObject.fromObject(person);
        logger.info(jsonObject);
        logger.info(jsonObject.toString());

        return jsonObject.toString();
    }

    public Object deletePerson(@PathVariable("id") int id) {
        logger.info("删除人员信息id=" + id);
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("msg", "删除人员信息成功");
        return jsonObject;
    }

    public @ResponseBody
    String addPerson(@RequestBody Person person) {
        logger.info("注册人员信息成功id=" + person.getUid());
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("msg", "注册人员信息成功");
        return jsonObject.toString();
    }

    public @ResponseBody Object updatePerson(@RequestBody Person person) {
        logger.info("更新人员信息id=" + person.getUid());
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("msg", "更新人员信息成功");
        return jsonObject.toString();
    }
}
5. 相关配置文件配置，整合SSM框架

web.xml配置文件

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<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/javaee
     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>springMVCRestful</display-name>

  <!--JDBC-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 防止Spring内存溢出监听器 -->
      <listener>
        <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
      </listener>


  <!-- spring mvc servlet-->
  <servlet>
    <servlet-name>springMVCRestful</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>springMVCRestful</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!-- 如果有乱码我们则需要配置字符编码集的过滤器来防止乱码问题 -->
  <!-- 编码过滤器 -->
      <filter>
        <filter-name>encodingFilter</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>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>

</web-app>

spring.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:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.ttook.springmvc"/>


    <!-- 第一种方式：加载一个properties文件 -->
    <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties"/>
    </bean>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${driverClasss}"/>
        <property name="url" value="${jdbcUrl}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
        <!-- 初始化连接大小 -->
        <property name="initialSize" value="${initialSize}"></property>
        <!--连接池最大数量 -->
        <property name="maxActive" value="${maxActive}"></property>
        <!--连接池最大空闲  -->
        <property name="maxIdle" value="${maxIdle}"></property>
        <!--连接池最小空闲  -->
        <property name="minIdle" value="${minIdle}"></property>
        <!--获取连接最大等待时间 -->
        <property name="maxWait" value="${maxWait}"></property>
    </bean>

    <!-- mybatis和spring完美整合，不需要mybatis的配置映射文件 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 自动扫描mapping.xml文件 -->
        <property name="mapperLocations" value="classpath:mapping/PersonMapper.xml"></property>
    </bean>

    <!-- DAO接口所在包名，Spring会自动查找其下的类 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.ttook.springmvc.dao"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>
    <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

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-3.0.xsd                        http://www.springframework.org/schema/context                     http://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"
>
    <!-- 初始化com.ttook.springmvc目录下面的bean  -->
    <context:component-scan base-package="com.ttook.springmvc"></context:component-scan>


    <!--避免IE执行AJAX时，返回JSON出现下载文件 -->
    <bean id="mappingJacksonHttpMessageConverter"   class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
        <property name="supportedMediaTypes">
            <list>
                <value>text/html;charset=UTF-8</value>
            </list>
        </property>
    </bean>
    <!-- 启动SpringMVC的注解功能，完成请求和注解POJO的映射 -->
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
            <list>
                <ref bean="mappingJacksonHttpMessageConverter"/> <!-- JSON转换器 -->
            </list>
        </property>
    </bean>

<!--配置spring MVC的注解 驱动 -->
<mvc:annotation-driven/>
</beans>

jdbc.properties文件

driverClasss=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://192.168.1.117:3306/数据库名?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull
username=账号
password=密码
#定义初始连接数
initialSize=0
#定义最大连接数
maxActive=20
#定义最大空闲
maxIdle=20
#定义最小空闲
minIdle=1
#定义最长等待时间
maxWait=60000
6. 请求接口地址并返回json数据
请求地址：
http://localhost:8088/lxf/test/getPerson/1001
返回值：
    {"uaddress":"北京","uage":27,"uid":1001,"uname":"XXX","usex":"男"}
lxf0515
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解手把手Maven搭建SpringMVC+Spring+MyBatis框架(超级详细版)
08-28
“手把手Maven搭建SpringMVC+Spring+MyBatis框架超级详细版” 本文主要介绍了手把手Maven搭建SpringMVC+Spring+MyBatis框架的详细步骤，该框架是当前较为主流的企业级架构方案。该框架基于标准的MVC设计模式，将...
搭建SSM（springMVC+spring+mybatis）框架的maven项目
07-14
搭建SSM（springMVC+spring+mybatis）框架的maven项目
Spring核心包，Maven引入
yc26583的博客
10-11 1202
Spring核心依赖包，Maven引入方式实现配置
如何在MAVEN中配置Spring的依赖包
lucky
09-06 1万+
1. 介绍 这篇文档介绍如何在Maven中配置Spring依赖，最新的Spring发布版可以在Maven仓库中找到。 2. 在Maven中Spring的基础配置 Spring是高度模块化的，可以单独使用Spring的某个库而不需要依赖Spring的其他库。比如，使用Spring Context库不需要依赖Spring Persistence或者Spring MVC库。 让我们先
SSM框架之spring核心包导入（Maven坐标）
dongzhanglong的博客
09-26 1043
定义spring版本 <properties> <!-- spring版本号 --> <spring.version>4.0.2.RELEASE</spring.version> </properties> spring核心包 <!-- spring核心包 --> <dependency> <groupId>org.springframework</groupId> &lt
项目Maven集成spring+springMVC所用jar包
点滴记录，积流成河！
09-28 1万+
pom.xml 文件： // 版本信息统一定义 4.0.4.RELEASE 5.1.34 --> 依赖包： org.springframework spring-aop ${spring.version} org.springframework spring-aspects ${spring.version} org.sp
手把手教你整合最优雅SSM框架：SpringMVC + Spring + MyBatis
热门推荐
小疯的代码健身房
05-08 61万+
小疯手把手带你整合SpringMVC+Spring+MyBatis三大框架，俗称SSM，用它完全代替传统的SSH框架，把它们最优雅的一面发挥出来。整合配置结束后，会有一个应用实例“图书管理系统”带给大家，希望能快速上手这个框架！
基于SpringMVC+Spring+MyBatis个人技术博客系统源码.zip
04-24
博客源码主要涉及技术包括的包括 Maven、Spring、SpringMVC、MyBatis、Redis、JSP等。后台地址：/admin 或者 /login 技术栈 SpringMVC + Spring + MyBatis 运行环境 IDEA + Tomcat8以上 + MySQL5.5以上 注意事项 ...
maven+springMVC+mybatis+velocity+mysql+junit项目框架搭建
11-06
maven+springMVC+mybatis+velocity+mysql+junit项目框架搭建
springmvc＋spring＋mybatis实现用户登录功能（上）
08-30
* SSM框架是Spring、SpringMVC和MyBatis的整合，它提供了一种灵活的Web应用程序开发方法。 * SSM框架的主要优点是提供了一个灵活的、可扩展的、松耦合的Web应用程序开发环境。 * SSM框架的整合可以简化Web应用程序的...
使用Maven管理Spring
weixin_34242819的博客
06-29 224
原文链接: Spring with Maven原文日期: 2013年04月17日翻译日期: 2014年06月29日翻译人员: 铁锚1. 概述本教程向您展示如何通过 Maven 管理 Spring 的依赖关系.最新的Spring版本可以在 Maven Central仓库 中找到. 也可以访问 mvnrepository：org.springframework.2. 使用Maven管理基本的Sp...
spring配置maven依赖核心jar
fz13768884254的博客
12-24 1812
&lt;!-- https://mvnrepository.com/artifact/org.springframework/spring-context --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework&lt;/groupId&gt; &lt;artifactId&gt;spring-context&lt;...
Spring核心包介绍
超威半导体
08-31 7010
Spring框架是一个严格的分层的架构组织起来的框架，所有的其他模块都是依赖于核心的core模块构建的，这些模块组成了成个企业级开发的所有组建，可以选择性的依赖需要的模块即可，不需要依赖多余的模块，这样模块化的集成避免很多不必要的维护和后期迭代的问题。整个Spring框架的结构图如下，下面分别介绍一下各个模块的功能。 Core模块：构建应用的核心，主要提供了依赖注入的特性，其中一个最抽象的接...
maven创建spring常用依赖包整理
酷酷的coder
04-28 1779
<properties> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> <project.build.sourceEncodin...
Spring数据访问架构设计解析
alan_gaohaodong的博客
06-24 368
3、事物事件监听器：@TransactionalEventListener，事物只有在commit后，才能把事件发出来。1、开启基于注解的声明式事物：@EnableTransactionManagement。1、Spring事物管理器：PlatformTransactionManager。2、Spring事物模板:TransactionTemplate。二、Spring声明式事物(aop原理)四、Spring R2DBC数据访问。二、Spring事物管理器。四、Spring事物管理器。
Spring中的Bean作用域有哪些
2301_76166241的博客
06-28 604
Spring中的BeanScope决定了容器在何时创建一个新的Bean实例以及何时重用现有实例。这对于控制应用程序中各个Bean的生命周期和状态非常重要。
Spring 内部类获取不到@Value配置值问题排查（附Spring代理方式）
YY-帆S的博客
06-24 688
异常处理、@Value 、Spring 代理模式
第三节：如何理解Spring的两个特性IOC和AOP（自学Spring boot 3.x第一天）
最新发布
Mero技术博客
06-28 496
通过使用IOC和AOP，我们可以降低代码的耦合度、提高代码的可维护性和可扩展性、减少代码的冗余和复杂性。实现与优势： 在传统的编程方式中，如果一个类A需要使用类B，那么A会自己去创建B的实例。而在使用Spring的IOC容器后，类A不再直接创建类B的实例，而是由Spring容器来创建并管理这些实例。其核心思想在于，资源的使用不由使用资源的各方管理，而是交给一个不直接使用资源的第三方进行管理。这样的好处是资源是集中管理的，可配置、易维护，同时也降低了双方的依赖度，实现了低耦合。
搭建SpringMVC +Spring + MyBatis的环境
05-31
搭建SpringMVC +Spring + MyBatis的环境，需要进行以下步骤： 1.搭建Maven项目：新建Maven项目，引入SpringMVC、Spring和MyBatis的相关依赖。 2.配置web.xml：在web.xml中配置DispatcherServlet，以便SpringMVC可以接收和处理请求。 3.配置Spring：在Spring的配置文件中，配置数据源和MyBatis的SqlSessionFactory，以及Spring和MyBatis的整合。 4.配置MyBatis：在MyBatis的配置文件中，配置Mapper的扫描路径和数据源。 5.创建Mapper和对应的Mapper.xml文件：创建Mapper接口和对应的Mapper.xml文件，定义SQL语句和参数映射。 6.在Service中注入Mapper：在Service中注入Mapper，并调用Mapper中的方法。 7.在Controller中调用Service：在Controller中注入Service，并调用Service中的方法，返回数据给前端。 以上就是搭建SpringMVC +Spring + MyBatis的环境的基本步骤，需要根据具体业务需求进行相应的配置和开发。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值