Eclipse转Idea后的初次构建基于maven的SSM项目

最新推荐文章于 2023-11-29 22:50:35 发布

執著丶

最新推荐文章于 2023-11-29 22:50:35 发布

阅读量393

点赞数 2

分类专栏： ssm 文章标签： IDEA ssm maven

本文链接：https://blog.csdn.net/qq_36489675/article/details/81283246

版权

ssm 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

从Eclipse转idea后，虽然感觉到很多不习惯，但是也被idea各种方便快捷的功能所吸引。先前都是使用Eclipse进行开发，然后毕业后的第一份工作要求使用Idea开发，在这半个月的接触中，感受到了这个编译工具的方便快捷。为了方便后续的学习，我决定开始结合这个工具搭建我最熟悉的ssm框架，并实现一个简陋的注册登录功能。

我先列出我先前搭建项目时参照的大神的文章

idea环境基于maven整合ssm

IntelliJ IDEA + Maven创建Java Web项目

由于文章中有些部分略过了，所以对于初次搭建的我来说，过程也是很艰难。
接着是我项目pom、spring配置文件、web.xml文件的参照文章:

SSM框架——详细整合教程（Spring+SpringMVC+MyBatis）

首先先建数据库

/*
Navicat MySQL Data Transfer

Source Server         : mydb
Source Server Version : 50640
Source Host           : localhost:3306
Source Database       : demossm

Target Server Type    : MYSQL
Target Server Version : 50640
File Encoding         : 65001

Date: 2018-08-03 14:05:59
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for tb_user
-- ----------------------------
DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  `pwd` varchar(15) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uni_name` (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

开始通过Idea 搭建基于maven的ssm项目

填写项目组织和项目名称

GroupID是项目组织唯一的标识符，实际对应JAVA的包的结构，是main目录里java的目录结构。

ArtifactID就是项目的唯一的标识符，实际对应项目的名称，就是项目根目录的名称

配置maven

这里没什么好改的，下一步

刚开始长这样

之后等待项目搭建，等待maven下载maven-archetype-plugin，如果失败了将本地仓库repository里的Maven-archetype-plugin（repository\org\apache\maven\plugins\maven-archetype-plugin）删了

构建成功后

然后加入依赖的jar包

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.cn</groupId>
  <artifactId>demo-ssm</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>demo-ssm Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <!-- spring版本号 -->
    <spring.version>4.0.2.RELEASE</spring.version>
    <!-- mybatis版本号 -->
    <mybatis.version>3.2.6</mybatis.version>
    <!-- log4j日志文件管理包版本 -->
    <log4j.version>1.2.17</log4j.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <!-- 表示开发的时候引入，发布的时候不会加载此包 -->
      <scope>test</scope>
    </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-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- Aspect -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</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-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>
    <!-- 导入java ee jar 包 -->
    <dependency>
      <groupId>javax</groupId>
      <artifactId>javaee-api</artifactId>
      <version>7.0</version>
    </dependency>
    <!-- 导入Mysql数据库链接jar包 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.30</version>
    </dependency>
    <!-- 导入dbcp的jar包，用来在applicationContext.xml中配置数据库 -->
    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>1.2.2</version>
    </dependency>
    <!-- JSTL标签类 -->
    <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>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.1.41</version>
    </dependency>
    <!-- log end -->
    <!-- 映入JSON -->
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>1.9.13</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>
    <!-- lombok -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.16.10</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>demo-ssm</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.7.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.20.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

然后将java、resources等文件加上（不知道为什么Idea没有帮我们创建），并将其设置为资源文件。若不这样设置是不能创建package和java类。（注意：我在创了java文件夹后将其底下的com.cn.controller、dao等包都创好了，然后做下步的设置，在后续的spring配置文件进行配置的时候，发现找不到com.cn、com.cn.controller、com.cn.dao这些包的路径）

通过设置

设置结果如图

也可以对资源文件夹右键Mark Directory as设置

之后创建java package

创好之后先配置属性文件

这里有遇到的bug，原本数据库的用户名设置为username但是后续服务器也启动了，没有报错，进行查询的时候却出错了，说我的username是Administrator，可我明明写的是root，之后找到了解决方法：https://blog.csdn.net/yuan882696yan/article/details/77345374

jdbc.properties

driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/demossm?useUnicode=true&characterEncoding=UTF-8
jdbc.username=root
jdbc.password=root

#定义初始连接数
initialSize=0
#定义最大连接数
maxActive=20
#定义最大空闲
maxIdle=20
#定义最小空闲
minIdle=1
#定义最长等待时间
maxWait=60000

log4j.properties

log4j.rootLogger=INFO,Console,File
#定义日志输出目的地为控制台
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out
#可以灵活地指定日志输出格式，下面一行是指定具体的格式
log4j.appender.Console.layout = org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n

#文件大小到达指定尺寸的时候产生一个新的文件
log4j.appender.File = org.apache.log4j.RollingFileAppender
#指定输出目录
log4j.appender.File.File = logs/ssm.log
#定义文件最大大小
log4j.appender.File.MaxFileSize = 10MB
#输出所以日志，如果换成DEBUG表示输出DEBUG以上级别日志
log4j.appender.File.Threshold = ALL
log4j.appender.File.layout = org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

mybatis-config.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>
    <settings>
        <!-- 打印查询语句 -->
        <setting name="logImpl" value="STDOUT_LOGGING" />
    </settings>

    <!-- mapper已经在spring-mybatis.xml中的sqlSessionFactory配置，这里不再需要配置 -->
    <!--     <mappers> -->
    <!--         <mapper resource="com/a/b/c/dao/BusinessInfoDaoMapper.xml" /> -->
    <!--     </mappers> -->
</configuration>

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: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-3.1.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-3.1.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-3.1.xsd">

    <!-- 组件扫描和自动装配 -->
    <context:component-scan base-package="com.cn.*"/>

    <!-- 引入配置文件 -->
    <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="${driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.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>

    <!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 自动扫描实体类 -->
        <property name="typeAliasesPackage" value="com.cn.entity"/>
        <!-- 自动扫描mapping.xml文件 -->
        <property name="mapperLocations" value="classpath:mappers/*.xml"></property>
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <!-- DAO接口所在包名，Spring会自动查找其下的类 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.cn.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>
    <tx:annotation-driven transaction-manager="transactionManager" />
</beans>

由于mappers里面还没有文件，所以此处

<property name="mapperLocations" value="classpath:mappers/*.xml"></property>

会报错，因为idea搜索不到mappers里面的文件，可以加一个xml文件，或者无视，在我们后续添加了mapper.xml这个报错就会消失

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

    <!-- 开启aop，对类代理-->
    <aop:aspectj-autoproxy proxy-target-class="true" />
    <!-- 自动扫描  @Controller-->
    <context:component-scan base-package="com.cn.controller"/>
    <mvc:annotation-driven />

     <!--避免IE执行AJAX时，下载JSON文件的现象 -->
    <bean id="mappingJacksonHttpMessageConverter"
          class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
        <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>

    <!-- 定义跳转的文件的前后缀 ，视图模式配置 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀，变成一个 可用的url地址 -->
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>

    <!-- 配置文件上传，如果没有使用文件上传可以不用配置，当然如果不配，那么配置文件中也不必引入上传组件包 -->
    <bean id="multipartResolver"
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 默认编码 -->
        <property name="defaultEncoding" value="utf-8" />
        <!-- 文件大小最大值 -->
        <property name="maxUploadSize" value="10485760000" />
        <!-- 内存中的最大值 -->
        <property name="maxInMemorySize" value="40960" />
    </bean>
</beans>

如果spring配置文件改动了位置，web.xml中要进行修改

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<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_3_0.xsd"
         version="3.0">
  <display-name>demo-ssm</display-name>
  <!-- Spring和mybatis的配置文件 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <!-- 编码过滤器 -->
  <filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <async-supported>true</async-supported>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF-8</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  <!-- Spring监听器 -->
  <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>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
  </servlet>
  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <!-- 默认为斜杆,此处可以可以配置成*.do，对应struts的后缀习惯 -->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
  <welcome-file-list>
    <welcome-file>/index.jsp</welcome-file>
  </welcome-file-list>

</web-app>

配置web目录、spring目录。如果Facets中没有的话，我们就需要添加了。或者IDEA无法识别web、spring等文件，我们都要进行修改

如果说中间列表没有Spring的话，就和添加web一样。

配置过程中IDEA刚好无法识别我的spring配置文件，如下图添加，添加完后点击apply

之后打开Artifacts看看是否有下图的exploded

没有的话点击加号添加，添加完后点击apply

配好了，开始创建java的类

最后的目录结构为

首先是实体类

实体类这里的使用了lombok框架，可以不用写get 、set等方法，不过idea要装上插件，否则会报错。

User

package com.cn.entity;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.io.Serializable;

/**
 * 描述:用户
 *
 * @author hewm
 * 2018-07-30 11:41:49 11:41
 */
@Setter
@Getter
@ToString
public class User implements Serializable{
    private static final long serialVersionUID = 1L;
    private Long id ;
    private String name;
    private String pwd;
}

创建dao接口

package com.cn.dao;

import com.cn.entity.User;
import org.springframework.stereotype.Repository;

/**
 * 描述:用户
 *
 * @author hewm
 * 2018-07-30 11:52:31 11:52
 */
@Repository
public interface UserDao {

    /**
     * 插入
     * @param user
     * @return
     */
    int insert(User user);

    /**
     * 查询获取单个实体
     * @param user
     * @return
     */
    User getByParam(User user);
}

创建service接口

package com.cn.service;

import com.cn.entity.User;

/**
 * 描述:用户
 *
 * @author hewm
 * 2018-07-30 11:57:12
 */

public interface UserService {

    /**
     * 插入
     * @param user
     * @return
     */
    int insert(User user);
    
    /**
     * 查询获取单个实体
     * @param user
     * @return
     */
    User getByParam(User user);

    /**
     * 测试事务回滚
     */
    void testRollback();
}

创建service实现类，记得加上@Service

package com.cn.service.impl;

import com.cn.dao.UserDao;
import com.cn.entity.User;
import com.cn.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * 描述:用户
 *
 * @author hewm
 * 2018-07-30 12:01:59 12:01
 */
@Transactional
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public int insert(User user) {
        return userDao.insert(user);
    }

    @Override
    public User getByParam(User user) {
        return userDao.getByParam(user);
    }

    @Override
    public void testRollback() {
        User u1 = new User();
        u1.setName("test1");
        u1.setPwd("test1");

        /**
         * 数据库中要求name字段长度为20,将插入的name设置为25位,
         * 之后先插入u1并从数据库获取,再插入u2，到数据库查看是否还有u1与u2的数据,
         * 没有则说明spring进行了事务管理
         */
        User u2 = new User();
        u2.setName("1234567890123456789012345");
        u2.setPwd("test2");

        userDao.insert(u1);
        System.out.println("已经添加u1,从数据库获取u1");
        User user1 = userDao.getByParam(u1);
        System.err.println(user1);


        userDao.insert(u2);
    }
}

添加3个jsp界面到views中

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <title>首页</title>

</head>

<body>
登录的用户是:
 ${user.name},密码为:${user.pwd}
</body>
</html>

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<c:set var="resourceRoot" value="${pageContext.servletContext.contextPath}"/>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css">
    <title>登录</title>
</head>
<body>
<div class="panel panel-default  col-sm-3">
    <div class="panel-heading">
        登录
    </div>
    <form action="${resourceRoot}/login" method="post" >
        <br>
    用户名:<input name="name" ><br><br>
        密&nbsp;&nbsp;&nbsp;&nbsp;码:<input type="password" name="pwd"><br><br>
        <input type="submit" value="提交">&nbsp;&nbsp;
        <a href="${resourceRoot}/register" >注册</a>
    </form>
    <br>
</div>

</body>
<script type="text/javascript">
    <c:if test="${not empty msg}">
    alert("${msg}");
    </c:if>
</script>
</html>

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<c:set var="resourceRoot" value="${pageContext.servletContext.contextPath}"/>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css">
    <title>注册</title>
</head>
<body>
    <div class="panel panel-default  col-sm-3">
        <div class="panel-heading">
            注册
        </div>
    <form action="${resourceRoot}/register" method="post" >
        <br>
        用户名:<input name="name" ><br><br>
        密&nbsp;&nbsp;&nbsp;&nbsp;码:<input type="password" name="pwd"><br><br>
        <input type="submit" value="注册">&nbsp;&nbsp;
        <a href="${resourceRoot}/login" >返回</a>
    </form>
        <br>
</div>
</body>
<c:if test="${not empty msg}">
    alert("${msg}");
</c:if>
</html>

创建ViewController

package com.cn.controller;

import com.cn.entity.User;
import com.cn.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 描述:用户
 *
 * @author hewm
 * 2018-07-30 14:16:44 14:16
 */
@Controller
@RequestMapping("")
public class ViewController {

    @Autowired
    private UserService userService;

    @RequestMapping(value = "/login" , method = RequestMethod.GET)
    public String login(){
        return "login";
    }

    @RequestMapping(value = "/login" , method = RequestMethod.POST)
    public String login(User u,  Model model){
        User user = userService.getByParam(u);
        if(user == null){
            model.addAttribute("msg", "账号或密码错误");
            return "login";
        }else
        return "index";
    }

    @RequestMapping(value = "/register" , method = RequestMethod.GET)
    public String register(){
        return "register";
    }

    @RequestMapping(value = "/register" , method = RequestMethod.POST)
    public String register(User user, Model model){
        userService.insert(user);
        if(user.getId()>0){
            model.addAttribute("msg", "注册成功");
            return "login";
        }else{
            model.addAttribute("msg", "注册失败");
            return "register";
        }
    }
    /**
     * 测试事务回滚
     * @return
     */
    @RequestMapping("testRollback")
    @ResponseBody
    public String  insert(){
        userService.testRollback();
        return "ok";
    }
}

再展示一次结构图

接着配置tomcat来启动服务

点击左上角绿色的加号，来新增tomcat

选择带有exploded的

选完之后再回到Server ,修改图中被圈住的部分,点击OK

启动服务

打开首页

接着注册一个账号并登陆，访问http://localhost:8080/web/login

点击注册

输入用户名:admin,密码:admin

点击注册，返回IDEA查看控制台，log4j是否有打印插入语句

插入成功，并且打印了语句，接着登陆

登陆成功。

接着我要测试，spring的事务管理是否能够实现，通过添加两个user，在添加第一个user成功之后，去数据库获取刚刚添加的user，然后抛出一个RuntimeException异常，再到数据库中查看是否有新增的user

UserServiceImpl中的

@Override
    public void testRollback() {
        User u1 = new User();
        u1.setName("test1");
        u1.setPwd("test1");

        User u2 = new User();
        u2.setName("test2");
        u2.setPwd("test2");

        userDao.insert(u1);
        System.out.println("已经添加u1,从数据库获取u1");
        User user1 = userDao.getByParam(u1);
        System.err.println(user1);
        if("test2".equals(u2.getName()))
            throw new RuntimeException();
        userDao.insert(u2);
    }

访问http://localhost:8080/web/testRollback

返回IDEA查看控制台

在数据库可以看到确实只有刚刚添加的admin，说明spring的事务管理生效，进行了回滚操作。

虽然功能比较简陋，但是ssm框架已经成功搭建起来了。

补充Spring AOP 基于注解的实现

我这里的AOP是controller的

在pom.xml中引入依赖，

<!-- Aspect -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>

在spring-mvc（注意！）的配置文件中加入

若把配置信息写在spring的配置文件中，aop将不会生效

接着写java类

如果没有引入上述提到的jar包，是无法使用@Aspect注解

package com.cn.aspect;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

/**
 * 描述:
 *
 * @author hewm
 * 2018-07-31 09:57:29 9:57
 */
@Component
@Aspect
public class ControllerAspect {
    private static final Logger logger = LogManager.getLogger(ControllerAspect.class);


    //配置切入点,该方法无方法体,主要为方便同类中其他方法使用此处配置的切入点
    @Pointcut("execution(public * com.cn.controller.*.*(..))")
    public void aspect(){}

    /*
     * 配置前置通知,使用在方法aspect()上注册的切入点
     * 同时接受JoinPoint切入点对象,可以没有该参数
     */
    @Before("aspect()")
    public void before(JoinPoint joinPoint){
        System.out.println("执行before.....");
    }

    //配置后置通知,使用在方法aspect()上注册的切入点
    @After("aspect()")
    public void after(JoinPoint joinPoint){
        System.out.println("执行after.....");
    }

    //配置环绕通知,使用在方法aspect()上注册的切入点
    @Around("aspect()")
    public Object around(ProceedingJoinPoint pjp)throws Throwable {

        RequestAttributes ra = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes sra = (ServletRequestAttributes) ra;
        HttpServletRequest request = sra.getRequest();

        String requestPath = request.getRequestURI();
        logger.info("访问路径:"+requestPath);
        return pjp.proceed();
    }

    //配置后置返回通知,使用在方法aspect()上注册的切入点
    @AfterReturning("aspect()")
    public void afterReturn(JoinPoint joinPoint){
        System.out.println("配置后置return通知");
    }

    //配置抛出异常后通知,使用在方法aspect()上注册的切入点
    @AfterThrowing(pointcut="aspect()", throwing="ex")
    public void afterThrow(JoinPoint joinPoint, Exception ex){
        System.out.println("配置抛出异常后通知");
    }

}

访问http://localhost:8080/web/login

控制台输出

后续需要进行操作再往AOP当中加入。

執著丶

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Eclipse转Idea后的初次构建基于maven的SSM项目

从Eclipse转idea后，虽然感觉到很多不习惯，但是也被idea各种方便快捷的功能所吸引。先前都是使用Eclipse进行开发，然后毕业后的第一份工作要求使用Idea开发，在这半个月的接触中，感受到了这个编译工具的方便快捷。为了方便后续的学习，我决定开始结合这个工具搭建我最熟悉的ssm框架，并实现一个简陋的注册登录功能。我先列出我先前搭建项目时参照的大神的文章 ...
复制链接

扫一扫