文档章节

采用Maven搭建一个分模块的SSM项目详细过程

Johnny丶Gao
 Johnny丶Gao
发布于 2017/05/18 18:28
字数 4378
阅读 328
收藏 0

1、搭建项目结构

        首先,利用Maven的继承和聚合特性搭建一个分模块的项目骨架,如下图所示样子,ssm-parent作为顶级父工程,打包方式为pom,主要用于集中管理项目中的依赖、插件、配置,同时它会聚合一些子模块,比如这里的ssm-common和ssm-manage两个子模块。

                                             

        ssm-common作为继承自ssm-parent的子模块,打包方式为jar,主要用于编写一些通用的功能模块以供其它模块使用;ssm-manage同样作为继承自ssm-parent的子模块,但是与ssm-common不同的是,ssm-manage也是一个聚合工程,打包方式为pom,它聚合了ssm-manage-pojo、ssm-manage-mapper、ssm-manage-service、ssm-manage-web四个子模块,而这四个子模块均直接继承自ssm-manage,同时也就间接继承自ssm-parent,它们的打包方式分别是jar、jar、jar、war,同时从名字也可以看出ssm-manage-pojo用于编写一些pojo类,ssm-manage-mapper用于编写一些MyBatis的Mapper类,ssm-manage-service用于编写一些service类,最后ssm-manage-web用于编写一些controller类,同时它们之间的依赖关系如下图,这四个模块一起就组成了传统的不分模块的web项目。所以,如果还需要在ssm-parent下建立其它的一些web工程,采用ssm-manage这种聚合的思路就可以了。

               

        接下来,在ssm-parent工程下的pom.xml文件中配置tomcat插件,因为不是所有子模块都需要用到该插件,所以将其配置在pluginManagement标签中进行管理

<properties>
    <tomcat.plugin.version>2.2</tomcat.plugin.version>
</properties>

<build>
    <pluginManagement>
        <plugins>
            <!-- 配置Tomcat7插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>${tomcat.plugin.version}</version>
            </plugin>
        </plugins>
    </pluginManagement>
</build>

        就目前而言,整个项目就ssm-manage聚合工程中拥有一个ssm-manage-web的web模块,所以接下来就需要在ssm-manage这个聚合工程中配置使用这个tomcat插件,一定要注意的是聚合工程的tomcat插件要配置在聚合工程的pom.xml文件中

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <configuration>
                <!-- http://127.0.0.1:{port}/{path} -->
                <path>/</path>
                <port>8080</port>
            </configuration>
        </plugin>
    </plugins>
</build>

        到这一步后就可以在ssm-manage聚合工程上执行mvn tomcat7:run命令来启动ssm-manage工程了。

2、集成Spring框架

        首先在ssm-manage-web模块中的web.xml文件中添加Spring的ApplicationContext载入监听器

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

        这个监听类在spring-web模块中,所以此时需要引入spring-web的依赖,首先在ssm-parent工程的pom.xml文件中配置该依赖,spring.version是配置在properties标签中的一个属性

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>

        接下来就需要配置使用该依赖了,但是现在的问题是包括ssm-manage这个聚合工程以及四个子模块在内一共有5个模块,到底应该是在哪个模块中配置使用该依赖呢?总的来说,聚合工程依赖的导入原则有三条:

  • 所有模块都需要用到的依赖应该在聚合工程中导入,因为这样,所有子模块都会自动继承下来
  • 在使用依赖的最底层导入
  • 运行时需要的依赖在web模块中导入,因为这样的依赖在编码的时候不会用到,只有在运行时才会用到,所以在web模块中导入是最合适的

        根据这个原则,那么这里的spring-web这个依赖就应该在ssm-manage-service模块中导入,因为在该模块中将来编写的一些Service类会用到spring-context、spring-beans等模块中的一些注解,而spring-web这个模块恰好又依赖了这些模块,所以只要引入了spring-web的依赖,根据依赖的传递性,就会引入spring-context、spring-beans等模块,所以应该在使用依赖的最底层导入,即ssm-manage-service模块

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
</dependency>

        spring-web模块依赖了其它的一些模块,如下图所示:

             

        接着,在Web应用中集成Spring框架时,Spring容器监听器默认加载/WEB-INF/applicationContext.xml文件,可以通过配置contextConfigLocation参数来指定监听器加载的文件路径以及要加载的文件,所以这里在ssm-manage-web的src/main/resources目录下建立一个spring目录,用于存储Spring的一些配置文件,并在其中编写一个叫做spring-context.xml的文件,然后在ssm-manage-web模块中的web.xml文件中配置Spring容器监听器加载该文件

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring/spring-context.xml</param-value>
</context-param>

        接下来,配置数据源,首先在ssm-manage-web模块的src/main/resources目录中编写一个名叫jdbc.properties的文件,用于配置数据库的一些连接信息

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/ssm?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
jdbc.username=root
jdbc.password=123456

        接着,在ssm-manage-web模块的src/main/resources/spring文件夹中的spring-context.xml文件中配置读取该文件,这种配置方式更底层一些

<!-- 读取资源文件,并使用Spring自带的占位符替换功能 -->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <!-- 允许JVM参数覆盖,就是说那些JVM -D的参数可以覆盖这些资源文件中的参数,比如java -Djdbc.username=zs -->
    <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
    <!-- 忽略没有找到的资源文件 -->
    <property name="ignoreResourceNotFound" value="true" />
    <!-- 配置资源文件 -->
    <property name="locations">
        <list>
            <value>classpath:jdbc.properties</value>
        </list>
    </property>
</bean>

        接着,在ssm-manage-web模块的src/main/resources/spring文件夹中编写一个叫做spring-datasource.xml的文件,用于配置数据源信息

<!-- 定义数据源 -->
<bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource" destroy-method="close">
    <!-- 数据库驱动 -->
    <property name="driverClass" value="${jdbc.driverClassName}" />
    <!-- 相应驱动的jdbcUrl -->
    <property name="jdbcUrl" value="${jdbc.url}" />
    <!-- 数据库的用户名 -->
    <property name="username" value="${jdbc.username}" />
    <!-- 数据库的密码 -->
    <property name="password" value="${jdbc.password}" />
    <!-- 检查数据库连接池中空闲连接的间隔时间,单位是分,如果要取消则设置为0 -->
    <property name="idleConnectionTestPeriodInMinutes" value="60" />
    <!-- 连接池中未使用的链接最大存活时间,单位是分,如果要永远存活设置为0 -->
    <property name="idleMaxAgeInMinutes" value="30" />
    <!-- 每个分区最大的连接数,判断依据:请求并发数 -->
    <property name="maxConnectionsPerPartition" value="100" />
    <!-- 每个分区最小的连接数 -->
    <property name="minConnectionsPerPartition" value="5" />
</bean>

        这里用到的是bonecp连接池,所以还需要在ssm-parent工程的pom.xml文件中配置管理bonecp的依赖以及数据库驱动的依赖

<dependency>
    <groupId>com.jolbox</groupId>
    <artifactId>bonecp-spring</artifactId>
    <version>${bonecp.spring.version}</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>${mysql.version}</version>
</dependency>

        然后,按照依赖导入原则,此时应该在ssm-manage-web模块中配置使用这两个依赖;接着在spring-context.xml文件中导入spring-datasource.xml文件

<import resource="spring-datasource.xml" />

        接着,在ssm-manage-service模块的src/main/java目录中创建一个com.ssm.manage.service包,用于编写一些Service类,并在ssm-manage-web模块的src/main/resources/spring/spring-context.xml文件中配置包扫描器

<!-- 包扫描器 -->
<context:component-scan base-package="com.ssm.manage.service"/>

        接着,在ssm-manage-web模块的src/main/resources/spring文件夹中建立一个叫做spring-transaction.xml的文件,用于配置事务

<!-- 定义事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>

<!-- 定义事务策略 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!-- 所有以query开头的方法都是只读的 -->
        <tx:method name="query*" read-only="true" />
        <!-- 其他方法使用默认事务策略 -->
        <tx:method name="*" />
    </tx:attributes>
</tx:advice>

<aop:config>
    <!-- pointcut元素定义一个切入点,execution中的第一个星号用于匹配方法的返回类型,这里表明匹配所有返回类型。
        com.ssm.manage.service.*.*(..)表明匹配com.ssm.manage.service包下的所有类的所有方法 -->
    <aop:pointcut id="txPointcut" expression="execution(* com.ssm.manage.service.*.*(..))" />
    <!-- 将定义好的事务处理策略应用到上述的切入点 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut" />
</aop:config>

        Spring的事务需要用到spring-jdbc和spring-aspects模块,所以还需要在ssm-parent工程的pom.xml文件中配置管理这两个依赖,并按照依赖导入原则,此时应该在ssm-manage-web模块中配置使用这两个依赖

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

        接着在spring-context.xml文件中导入spring-transaction.xml文件

<import resource="spring-transaction.xml" />

3、Spring与MyBatis集成

        首先,在ssm-parent工程的pom.xml文件中配置管理Mybatis以及与Spring集成所需依赖

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>${mybatis.version}</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>${mybatis.spring.version}</version>
</dependency>

        然后,按照依赖导入原则,此时应该在ssm-manage-web模块中配置使用mybatis-spring这个依赖;而由于以后会在ssm-manage-service模块中使用MyBatis的分页插件,这个插件会用到MyBatis的一些API,所以应该在ssm-manage-service模块中配置使用mybatis这个依赖。

        接着,在ssm-manage-web的src/main/resources目录下建立一个mybatis目录,并在该目录下创建一个名叫mybatis-config.xml的文件,该配置文件目前不需要配置什么内容,为以后添加一些配置做准备;并在mybatis目录下创建一个mappers目录,以后的一些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>
    
</configuration>

        接着,在ssm-manage-pojo模块的src/main/java目录中创建一个com.ssm.manage.pojo包,用于存放一些简单pojo类,并在ssm-manage-mapper模块的src/main/java目录中创建一个com.ssm.manage.mapper包,用于存放一些mapper接口;然后在ssm-manage-web的src/main/resources/spring目录下建立一个spring-mybatis.xml文件,集成mybatis

<bean class="org.mybatis.spring.SqlSessionFactoryBean">
    <!-- 指定数据源 -->
    <property name="dataSource" ref="dataSource"/>
    <!-- 指定mybatis的全局配置文件 -->
    <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"/>
    <!-- 指定mapper.xml文件,扫描所有的文件 -->
    <property name="mapperLocations" value="classpath:mybatis/mappers/**/*.xml"/>
    <!-- 指定别名包 -->
    <property name="typeAliasesPackage" value="com.ssm.manage.pojo"/>
</bean>

<!-- 定义Mapper接口的扫描器 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.ssm.manage.mapper"/>
</bean>

        最后在spring-context.xml文件中导入spring-mybatis.xml文件

<import resource="spring-mybatis.xml" />

        此时如果在ssm-manage聚合工程上执行mvn tomcat7:run命令来启动ssm-manage工程会得到“class path resource [mybatis/mappers/] cannot be resolved to URL because it does not exist”的错误,这是因为mybatis/mappers目录下还没有任何映射文件,此时可以临时将spring-mybatis.xml文件中这一行代码注释掉即可,待以后有需要加载的mappers映射文件时再来取消注释即可

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

        在这里我们采用通用Mapper的方式来进行开发,所以还需要配置通用Mapper,首先在ssm-parent工程的pom.xml文件中配置管理通用Mapper所需依赖

<dependency>
    <groupId>com.github.abel533</groupId>
    <artifactId>mapper</artifactId>
    <version>${mybatis.mapper.version}</version>
</dependency>

        然后,按照依赖导入原则,此时应该在ssm-manage-pojo模块中配置使用这个依赖,因为使用通用Mapper时会在POJO上配置一些JPA注解,而这个依赖恰好依赖了JPA的一些API。

        接着,在ssm-manage-web的src/main/resources/mybatis目录中的mybatis-config.xml文件中配置通用Mapper插件

<plugins>
    <!-- 通用Mapper -->
    <plugin interceptor="com.github.abel533.mapperhelper.MapperInterceptor">
        <!-- UUID生成策略 -->
        <!-- 配置UUID生成策略需要使用OGNL表达式 -->
        <!-- 默认值32位长度:@java.util.UUID@randomUUID().toString().replace("-", "") -->
        <!-- <property name="UUID" value="@java.util.UUID@randomUUID().toString()"/> -->
        <!-- 主键自增回写方法,默认值MYSQL -->
        <property name="IDENTITY" value="MYSQL" />
        <!-- 序列的获取规则,使用{num}格式化参数,默认值为{0}.nextval,针对Oracle -->
        <!-- 可选参数一共3个,对应0,1,2,分别为SequenceName,ColumnName,PropertyName -->
        <!-- <property name="seqFormat" value="{0}.nextval" /> -->
        <!-- 主键自增回写方法执行顺序,默认AFTER,可选值为(BEFORE|AFTER) -->
        <property name="ORDER" value="AFTER" />
        <!-- 通用Mapper接口,多个通用接口用逗号隔开 -->
        <property name="mappers" value="com.github.abel533.mapper.Mapper"/>
    </plugin>
</plugins>

        接下来,一般项目中都会使用到分页查询的功能,所以这里我们用到了MyBatis的分页插件,首先,在ssm-parent工程的pom.xml文件中配置管理MyBatis分页插件所需依赖

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>${mybatis.pagehelper.version}</version>
</dependency>

        然后,按照依赖导入原则,此时应该在ssm-manage-service模块中配置使用这个依赖,因为在编写Service时会用到分页插件提供的一些API。

        接着,在ssm-manage-web的src/main/resources/mybatis目录中的mybatis-config.xml文件中配置MyBatis分页插件,注意:一定要将分页插件配置在第一个,通用Mapper配置在最后一个,否则会出现这样的错误:“java.lang.NoSuchMethodException: com.github.abel533.mapper.MapperProvider.<init>()”

<plugin interceptor="com.github.pagehelper.PageHelper">
    <!-- 没有默认值,必须指定该属性 -->
    <property name="dialect" value="mysql"/>
    <!-- 该参数默认为false -->
    <!-- 设置为true时,会将RowBounds第一个参数offset当成pageNum页码使用,可以用页码和页面大小两个参数进行分页 -->
    <!-- 和startPage中的pageNum效果一样 -->
    <property name="offsetAsPageNum" value="false"/>
    <!-- 该参数默认为false -->
    <!-- 设置为true时,使用RowBounds分页会进行count查询 -->
    <property name="rowBoundsWithCount" value="true"/>
    <!-- 该参数默认为false -->
    <!-- 设置为true时,如果pageSize = 0或者RowBounds.limit = 0就会查询出全部的结果 -->
    <!-- (相当于没有执行分页查询,但是返回结果仍然是Page类型)-->
    <property name="pageSizeZero" value="false"/>
    <!-- 3.3.0版本可用 - 分页参数合理化,默认false禁用 -->
    <!-- 启用合理化时,如果pageNum < 1会查询第一页,如果pageNum > pages会查询最后一页 -->
    <!-- 禁用合理化时,如果pageNum < 1或pageNum > pages会返回空数据 -->
    <property name="reasonable" value="false"/>
</plugin>

4、集成Spring MVC

        首先,在ssm-parent工程的pom.xml文件中配置管理Spring MVC所需依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>${spring.version}</version>
</dependency>

        然后,按照依赖导入原则,此时应该在ssm-manage-web模块中配置使用这个依赖

        接着,在ssm-manage-web模块的src/main/java目录下创建一个com.ssm.manage.controller包,用于编写一些Spring Controller类;并在src/main/webapp/WEB-INF目录下创建一个views目录,用于存放一些JSP文件

        接着,在ssm-manage-web模块的src/main/resources/spring目录中创建一个spring-mvc.xml文件,用于配置一些关于Spring MVC的信息

<!-- 定义注解驱动 -->
<mvc:annotation-driven />

<!-- 定义Controller的扫描包 -->
<context:component-scan base-package="com.ssm.manage.controller"/>

<!-- 定义试图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	<property name="prefix" value="/WEB-INF/views/"/>
	<property name="suffix" value=".jsp"/>
</bean>

        接下来,配置ssm-manage-web模块中的web.xml文件,配置Spring MVC相关信息

<!-- 配置Spring MVC框架入口 -->
<servlet>
  <servlet-name>ssm-manage</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <!-- 默认加载的是/WEB-INF/${servlet-name}-servlet.xml配置文件 -->
  <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring/spring-mvc.xml</param-value>
  </init-param>
  <!-- 取值为0或1,表示false/true,表示是否在容器启动时初始化这个servlet,否则在第一次访问的时候才去初始化 -->
  <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
  <servlet-name>ssm-manage</servlet-name>
  <!-- 配置方式有以下三种 -->
  <!-- / -->
  <!-- /xxx/* -->
  <!-- *.xxx,比如*.do,而在写Controller时映射路径上可以不写.xxx后缀也是可以的 -->
  <!-- 特别的,不能配置为/*,/*在struts中是可以的,但是在Spring MVC中是不行的,因为入口不同 -->
  <!-- struts的入口是一个过滤器,而Spring MVC是一个servlet,servlet是不能使用/*的,/*表示全部 -->
  <!-- 在servlet中表示全部用/ -->
  <url-pattern>/rest/*</url-pattern>
</servlet-mapping>

5、其他一些配置

        首先,在使用SpringMVC框架时一般都会用到Json序列化,比如用到@ResponseBody注解,所以还需要在ssm-parent模块的pom.xml文件中配置管理Json序列化依赖,然后根据依赖导入原则,还需要在ssm-manage-web模块中配置使用该依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>${jackson.version}</version>
</dependency>

        接着,在ssm-manage-web模块的web.xml文件中添加CharacterEncodingFilter过滤器来解决POST请求乱码的问题,要注意的是这个过滤器不能解决GET请求乱码问题

<filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
      <param-name>encoding</param-name>
      <param-value>UTF8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

        接着,引入日志框架,这里采用的是slf4j作为抽象的日志框架,而采用logback作为具体的日志框架,所以首先在ssm-parent模块的pom.xml文件中配置管理这些依赖,由于logback是slf4j的原生实现,所以不需要像使用log4j作为具体的日志框架时还需要引入适配器依赖

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>${slf4j.version}</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>${logback.version}</version>
</dependency>

        根据依赖导入原则,此时应该在ssm-manage这个聚合模块中配置使用slf4j这个依赖,而logback这个依赖在ssm-manage-web模块中配置使用就好

        接着,在ssm-manage-web模块的src/main/resources目录下新建一个logback.xml的日志配置文件,具体内容如下,到时候根据具体使用情况进行修改

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder charset="UTF-8">
            <pattern>%d{MM-dd HH:mm:ss} [%thread] [%-5level] %msg -%logger{35}:%L%n</pattern>
        </encoder>
    </appender>

    <appender name="DAYFILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>ssm.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>ssm.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
            <totalSizeCap>3GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>%d{MM-dd HH:mm:ss} [%thread] [%-5level] %msg -%logger{35}:%L%n</pattern>
        </encoder>
    </appender>

    <root level="debug">
        <appender-ref ref="STDOUT"/>
        <appender-ref ref="DAYFILE"/>
    </root>
</configuration>

        接着,在ssm-parent模块的pom.xml文件中配置管理单元测试Junit的依赖,并根据依赖导入原则,在ssm-manage聚合工程中配置使用该依赖

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>${junit.version}</version>
    <scope>test</scope>
</dependency>

        接着,配置一些通用的依赖,并根据依赖导入原则,各自在相应的模块中配置使用这些依赖

<!-- JSP相关 -->
<dependency>
    <groupId>jstl</groupId>
    <artifactId>jstl</artifactId>
    <version>${jstl.version}</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>${servlet-api.version}</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jsp-api</artifactId>
    <version>${jsp-api.version}</version>
    <scope>provided</scope>
</dependency>

<!-- Apache工具组件 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>${commons-lang3.version}</version>
</dependency>

<!-- httpclient -->
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>${httpclient.version}</version>
</dependency>

 

© 著作权归作者所有

Johnny丶Gao
粉丝 0
博文 46
码字总数 80983
作品 0
成都
私信 提问
ZHENFENGSHISAN/perfect-ssm

Quick Start 项目简介 ssm系列 ssm-demo:Spring+SpringMVC+Mybatis+easyUI整合 perfect-ssm:RESTful API+redis缓存 ssm-cluster:前后端分离+集群部署 ssm-dubbo:dubbo服务化 ssm-micro-se......

ZHENFENGSHISAN
2017/09/18
0
0
SSM三大框架整合详细教程(Spring+SpringMVC+MyBatis)【转】

使用SSM(Spring、SpringMVC和Mybatis)已经有三个多月了,项目在技术上已经没有什么难点了,基于现有的技术就可以实现想要的功能,当然肯定有很多可以改进的地方。之前没有记录SSM整合的过程...

如何让他和
2016/10/11
99
1
SSM三大框架整合详细教程(Spring+SpringMVC+MyBatis)【转】

使用SSM(Spring、SpringMVC和Mybatis)已经有三个多月了,项目在技术上已经没有什么难点了,基于现有的技术就可以实现想要的功能,当然肯定有很多可以改进的地方。之前没有记录SSM整合的过程...

梵蒂冈考虑过
2016/09/26
82
1
SSM三大框架整合详细教程(Spring+SpringMVC+MyBatis)【转】

使用SSM(Spring、SpringMVC和Mybatis)已经有三个多月了,项目在技术上已经没有什么难点了,基于现有的技术就可以实现想要的功能,当然肯定有很多可以改进的地方。之前没有记录SSM整合的过程...

看到了打开了
2016/11/05
99
1
SSM三大框架整合详细教程(Spring+SpringMVC+MyBatis)【转】

使用SSM(Spring、SpringMVC和Mybatis)已经有三个多月了,项目在技术上已经没有什么难点了,基于现有的技术就可以实现想要的功能,当然肯定有很多可以改进的地方。之前没有记录SSM整合的过程...

结构好可
2016/09/26
111
1

没有更多内容

加载失败,请刷新页面

加载更多

《Designing.Data-Intensive.Applications》笔记 四

第九章 一致性与共识 分布式系统最重要的的抽象之一是共识(consensus):让所有的节点对某件事达成一致。 最终一致性(eventual consistency)只提供较弱的保证,需要探索更高的一致性保证(stro...

丰田破产标志
今天
6
0
docker 使用mysql

1, 进入容器 比如 myslq1 里面进行操作 docker exec -it mysql1 /bin/bash 2. 退出 容器 交互: exit 3. mysql 启动在容器里面,并且 可以本地连接mysql docker run --name mysql1 --env MY...

之渊
今天
7
0
python数据结构

1、字符串及其方法(案例来自Python-100-Days) def main(): str1 = 'hello, world!' # 通过len函数计算字符串的长度 print(len(str1)) # 13 # 获得字符串首字母大写的...

huijue
今天
5
0
OSChina 周日乱弹 —— 我,小小编辑,食人族酋长

Osc乱弹歌单(2019)请戳(这里) 【今日歌曲】 @宇辰OSC :分享娃娃的单曲《飘洋过海来看你》: #今日歌曲推荐# 《飘洋过海来看你》- 娃娃 手机党少年们想听歌,请使劲儿戳(这里) @宇辰OSC...

小小编辑
今天
1K
11
MongoDB系列-- SpringBoot 中对 MongoDB 的 基本操作

SpringBoot 中对 MongoDB 的 基本操作 Database 库的创建 首先 在MongoDB 操作客户端 Robo 3T 中 创建数据库: 增加用户User: 创建 Collections 集合(类似mysql 中的 表): 后面我们大部分都...

TcWong
今天
40
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部