Java--Spring应用在Web项目

1、创建web的maven项目；类型 maven-archetype-webapp

2、加入maven的依赖

（1）spring依赖

（2）mybatis依赖

（3）mysql驱动

（4）spring的事务依赖

（5）mybatis和spring集成依赖

（6）加入jsp，servlet依赖

pom.xml文件


<dependencies>
 
    <!-- 单元测试依赖 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
 
    <!--spring依赖  核心IoC-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!-- spring事务 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
 
    <!-- mybatis事务 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>
 
    <!-- spring和mybatis集成依赖 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.1</version>
    </dependency>
 
    <!-- mysql驱动 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.9</version>
    </dependency>
 
    <!-- 阿里数据库连接池Druid -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.2.6</version>
    </dependency>
 
    <!-- servlet依赖 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
 
    <!-- jsp依赖 -->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2.1-b03</version>
      <scope>provided</scope>
    </dependency>
 
  </dependencies>

3、创建domain实体类


public class User {
    private int userId;
    private String userName;
    private String email;
    private int age;
 
    public int getUserId() {
        return userId;
    }
 
    public void setUserId(int userId) {
        this.userId = userId;
    }
 
    public String getUserName() {
        return userName;
    }
 
    public void setUserName(String userName) {
        this.userName = userName;
    }
 
    public String getEmail() {
        return email;
    }
 
    public void setEmail(String email) {
        this.email = email;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
}

4、创建dao接口和mapper文件


public interface UserDao {
    /**
     * 插入一条user记录
     * @param user
     * @return
     */
    int insertUser(User user);
 
    /**
     * 查询所有用户
     * @param user
     * @return
     */
    List selectUsers(User user);
}


"1.0" encoding="UTF-8" ?>
mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mycompany.dao.UserDao">
 
  <insert id="insertUser">
    insert into user values(#{userId},#{userName},#{email},#{age})
  insert>
 
  <select id="selectUsers" resultType="User">
    select user_id,user_name,email,age
    from user
    order by user_id desc
  select>
mapper>

5、创建mybatis主配置文件


"1.0" encoding="UTF-8" ?>
configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
 
    
    <settings>
        
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    settings>
 
    
    <typeAliases>
        
        
 
        
        <package name="com.mycompany.domain" />
    typeAliases>
 
 
    
    
 
 
    
    <mappers>
        
        
 
        
        <package name="com.mycompany.dao" />
 
    mappers>
 
configuration>

6、创建service接口和实现类，属性是dao


public class UserServiceImpl implements UserService {
    private UserDao userDao;
 
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
 
    @Override
    public int insertUser(User user) {
        int nums = userDao.insertUser(user);
        return nums;
    }
 
    @Override
    public List selectUsers(User user) {
        List userList = userDao.selectUsers(user);
        return userList;
    }
}

7、创建spring的配置文件：声明mybatis对象交给spring创建

（1）数据源DataSource

（2）SqlSessionFactory

（3）Dao对象

（4）声明自定义的service

spring.xml


"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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd">
 
    
    <context:property-placeholder location="classpath:jdbc.properties"/>
 
    
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close" >
        
        
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxActive" value="${jdbc.maxActive}"/>
    bean>
 
    
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        
        <property name="dataSource" ref="myDataSource"/>
 
        
        <property name="configLocation" value="classpath:mybatis.xml"/>
    bean>
 
    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
 
        
        <property name="basePackage" value="com.mycompany.dao"/>
    bean>
 
    
    <bean id="userService" class="com.mycompany.service.impl.UserServiceImpl">
        
        <property name="userDao" ref="userDao"/>
    bean>
 
beans>

8、创建一个jsp发起请求，参数是domain包中实体类的参数


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Titletitle>
head>
<body>
    <p>注册用户p>
    <form action="register" method="post">
        <table>
            <tr>
                <td>idtd>
                <td><input type="text" name="userId">td>
            tr>
            <tr>
                <td>姓名：td>
                <td><input type="text" name="userName">td>
            tr>
            <tr>
                <td>邮箱：td>
                <td><input type="text" name="email">td>
            tr>
            <tr>
                <td>年龄：td>
                <td><input type="text" name="age">td>
            tr>
            <tr>
                <td><input type="submit" value="注册学生">td>
            tr>
        table>
    form>
body>
html>

9、创建Servlet，接收请求参数


public class RegisterServlet extends HttpServlet {
 
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        String userId = req.getParameter("userId");
        String userName = req.getParameter("userName");
        String email = req.getParameter("email");
        String age = req.getParameter("age");
 
        User user = new User();
//        user.setUserId(Integer.parseInt(userId));
        user.setUserName(userName);
        user.setEmail(email);
        user.setAge(Integer.valueOf(age));
 
        //创建spring容器
        String config = "spring.xml";
        ApplicationContext wac = new ClassPathXmlApplicationContext(config);
 
        System.out.println("容器对象的信息========" + wac);
 
        //获取UserService
        UserService userService = (UserService) wac.getBean("userService");
        userService.insertUser(user);
 
        //反馈请求结果页面
        req.getRequestDispatcher("/result.jsp").forward(req,resp);
    }
 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 
    }
}

10、配置web.xml文件，web.xml 注册 Servlet


"1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee
         https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">
 
    
 
    
    <servlet>
        <servlet-name>RegisterServletservlet-name>
        <servlet-class>com.mycompany.controller.RegisterServletservlet-class>
    servlet>
    <servlet-mapping>
        
        <servlet-name>RegisterServletservlet-name>
        
        <url-pattern>/registerurl-pattern>
    servlet-mapping>
    
web-app>

项目自带web.xml文件如下；使用的是最低版本2.3，因此需要更改版本

（1）File ----> Project Structure...

（2）删掉项目自带的web.xml文件

（3）新增web.xml文件，并且选择版本

注：这里需要重新命名web.xml文件，如web1111.xml，如果还是使用web.xml名称，新建之后还是最低版本，因此需要重新命名！！！

（4）更改新增之后的web.xml文件名称，将其改为“web.xml”

11、调用Service，调用DAO完成注册，创建一个jsp作为显示结果页面

这里需要注意

JavaSE项目有main方法的，执行代码是执行main方法的，在main里面创建的容器对象

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

web项目是在tomcat服务器上运行的；只要 tomcat一起动，项目就会一直运行

安装配置Tomcat可自行百度，这里只说明IDEA上启动Tomcat

（1）工具栏上【Run】----> 【Edit Configurations...】

或者运行按钮旁边，选择【Edit Configurations...】

（2）点击添加，选择Tomcat Server ----> Local

如果这里没有Tomcat Server 选项；有可能是tomcat插件没启用，我们点击

file---->setting---->搜索tomcat---->勾选上

（3）配置Tomcat的信息

（4）点击Deployment----加号➕----Artifact...，配置访问路径

对应web.xml文件中的url-pattern 访问的路径

输入的访问地址为网址+端口号+工程名+访问的路径；如：

启动Tomcat 输入：http://localhost:8888/spring-web/

当表单提交，跳转成功后，多刷新几次页面，查看后台输出，发现每刷新一次页面，就 new 出一个新的Spring 容器。即每提交一次请求，就会创建一个新的 Spring 容器。对于一个应用来说，只需要一个 Spring 容器即可。所以，将 Spring 容器的创建语句放在 Servlet 的 doGet()或 doPost()方法中是有问题的

此时，可以考虑，将 Spring 容器的创建放在 Servlet 进行初始化时进行，即执行 init()方法时执行。并且，Servlet 还是单例多线程的，即一个业务只有一个 Servlet 实例，所有执行该业务的用户执行的都是这一个 Servlet 实例。这样，Spring 容器就具有了唯一性了。

但是，Servlet 是一个业务一个 Servlet 实例，即 LoginServlet 只有一个，但还会StudentServlet、TeacherServlet 等。每个业务都会有一个 Servlet，都会执行自己的 init()方法，也就都会创建一个 Spring 容器了。这样一来，Spring 容器就又不唯一了

对于 Web 应用，ServletContext 对象是唯一的，一个 Web 应用，只有一个ServletContext 对象，该对象是在 Web 应用装载时初始化的。若将 Spring 容器的创建时机，放在 ServletContext 初始化时，就可以保证 Spring 容器的创建只会执行一次，也就保证了Spring 容器在整个应用中的唯一性。

当 Spring 容器创建好后，在整个应用的生命周期过程中，Spring 容器应该是随时可以被访问的。即，Spring 容器应具有全局性。而放入 ServletContext 对象的属性，就具有应用的全局性。所以，将创建好的 Spring 容器，以属性的形式放入到 ServletContext 的空间中，就保证了 Spring 容器的全局性

（1）pom.xml加载监听器对象依赖


    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webartifactId>
      <version>5.2.5.RELEASEversion>
    dependency>

（2）注册监听器 ContextLoaderListener

在 ServletContext 初始化时创建 Spring 容器，就需要使用监听器接口

ServletContextListener 对 ServletContext 进行监听。在 web.xml 中注册该监听器。


<listener>
        <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
    listener>

ContextLoaderListener 的源码。看到一共四个方法，两个是构造方法，一个初始化方法，一个销毁方法

初始化容器；创建容器对象，并将容器对象放入到了 ServletContext 的空间中


public void contextInitialized(ServletContextEvent event) {
        this.initWebApplicationContext(event.getServletContext());
    }

创建容器对象

且将创建好的对象放入容器中

servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

（3）指定Spring配置文件位置

默认的 Spring 配置文件位置与名称为：WEB-INF/applicationContext.xml。但，一般会将该配置文件放置于项目的 classpath 下，即 src 下，所以需要在 web.xml 中对 Spring 配置文件的位置及名称进行指定


    <context-param>
        
        <param-name>contextConfigLocationparam-name>
        
        <param-value>classpath:spring.xmlparam-value>
    context-param>

监听器ContextLoaderListener的父类ContextLoader的中，其要读取的配置文件位置参数名称contextConfigLocation

（4）获取Spring容器对象

【1】直接从ServletContext中获取


WebApplicationContext wac = null;
 
//获取ServletContext中的容器对象
String key = WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE;
Object attr = getServletContext().getAttribute(key);
    if (attr != null){
        wac = (WebApplicationContext) attr;
    }

【2】通过WebApplicationContextUtils获取

WebApplicationContextUtils调用关系


public abstract class WebApplicationContextUtils {
    private static final boolean jsfPresent = ClassUtils.isPresent("javax.faces.context.FacesContext", RequestContextHolder.class.getClassLoader());
 
    public WebApplicationContextUtils() {
    }
 
    public static WebApplicationContext getRequiredWebApplicationContext(ServletContext sc) throws IllegalStateException {
        WebApplicationContext wac = getWebApplicationContext(sc);
        if (wac == null) {
            throw new IllegalStateException("No WebApplicationContext found: no ContextLoaderListener registered?");
        } else {
            return wac;
        }
    }
 
    @Nullable
    public static WebApplicationContext getWebApplicationContext(ServletContext sc) {
        return getWebApplicationContext(sc, WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
    }
 
    @Nullable
    public static WebApplicationContext getWebApplicationContext(ServletContext sc, String attrName) {
        Assert.notNull(sc, "ServletContext must not be null");
        Object attr = sc.getAttribute(attrName);
        if (attr == null) {
            return null;
        } else if (attr instanceof RuntimeException) {
            throw (RuntimeException)attr;
        } else if (attr instanceof Error) {
            throw (Error)attr;
        } else if (attr instanceof Exception) {
            throw new IllegalStateException((Exception)attr);
        } else if (!(attr instanceof WebApplicationContext)) {
            throw new IllegalStateException("Context attribute is not of type WebApplicationContext: " + attr);
        } else {
            return (WebApplicationContext)attr;
        }
    }


WebApplicationContext wac = null;
 
 
//使用框架中方法，获取容器对象
ServletContext sc = getServletContext();
wac = WebApplicationContextUtils.getRequiredWebApplicationContext(sc);

这时在多次刷新页面，发现对象始终是那一个

相关阅读:
特殊类设计
 百度指数 Cipher-Text、百度翻译 Acs-Token 逆向分析
 JUC并发编程——各种锁的理解（基于狂神说的学习笔记）
C#控制台相关方法
 JDS-12时间继电器
 阿里P8大佬，耗时三年心血出品的Spring实战全家桶，涨薪8K的秘密
 2021年认证杯SPSSPRO杯数学建模A题(第一阶段)医学图像的配准全过程文档及程序
 学习笔记-TP5框架学习笔记\(路由\)
秦简总经理王建忠：论都江堰泛计算操作系统的商业价值
 人工智能轨道交通行业周刊-第7期（2022.8.1-8.7）
原文地址：https://blog.csdn.net/MinggeQingchun/article/details/123247127