Maven POM 文件备份

最新推荐文章于 2024-07-17 17:10:14 发布
jonny6015
最新推荐文章于 2024-07-17 17:10:14 发布
阅读量524
点赞数
分类专栏： Java框架文章标签： maven pom
本文链接：https://blog.youkuaiyun.com/u011977189/article/details/78935841
版权
Java框架专栏收录该内容
2 篇文章
订阅专栏
本文探讨了如何结合Maven、SSM框架和Dubbo实现分布式服务，并提到了相关构建工具和插件的应用。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >
Maven + SSM 框架 + Dubbo分布式服务及一些插件。

<?xml version="1.0" encoding="UTF-8"?>
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements.  See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License.  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<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>cn.lmsite</groupId>
    <artifactId>lmsite</artifactId>
    <version>0.1</version>
    <packaging>pom</packaging>
    <name>lmsite</name>
    <description>lmsite is my private project.</description>
    <url>http://maven.apache.org</url>
    <inceptionYear>2017</inceptionYear>
    <licenses>
        <license>
            <name>Apache 2</name>
            <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
        </license>
    </licenses>
    <organization>
        <name>The LMS Project</name>
        <url>http://lmsite.cn</url>
    </organization>

    <!--Maven的properties是值占位符，就像Ant中的属性一样。它们的值可以在POM中的任何地方通过使用符号${X}来访问，其中X是属性。或者它们可以被插件用作默认值。-->
    <properties>

        <!--项目设置参数  Begin-->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <jdk.version>1.8.0_152</jdk.version>
        <encoding>UTF-8</encoding>
        <center.project.name>${project.artifactId}</center.project.name>
        <profiles.dir>src/profiles</profiles.dir>
        <!--项目设置参数  End-->

        <!--测试相关组件  Begin-->
        <junit.version>4.12</junit.version>
        <!--测试相关组件  End-->

        <javaee-api.version>8.0</javaee-api.version>

        <!--Spring 核心组件  Begin-->
        <spring.version>5.0.2.RELEASE</spring.version>
        <spring-instrument-tomcat.version>4.3.13.RELEASE</spring-instrument-tomcat.version>
        <spring-webmvc-portlet.version>4.3.13.RELEASE</spring-webmvc-portlet.version>
        <!--Spring 核心组件  End-->

        <!--数据库相关组件  Begin-->
        <mysql-connector-java.version>5.1.45</mysql-connector-java.version>
        <druid.version>1.1.6</druid.version>
        <!--数据库相关组件  End-->

        <!--MyBatis相关组件  Begin-->
        <mybatis.version>3.4.5</mybatis.version>
        <mybatis-spring>1.3.1</mybatis-spring>
        <mybatis-generator-core.version>1.3.6</mybatis-generator-core.version>
        <pagehelper.version>5.1.2</pagehelper.version>
        <mapper.version>3.4.6</mapper.version>
        <!--MyBatis相关组件  End-->

        <!--Apache 相关组件  Begin-->
        <commons-beanutils.version>1.9.3</commons-beanutils.version>
        <commons-collections4.version>4.1</commons-collections4.version>
        <httpclient.version>4.5.4</httpclient.version>
        <lombok.version>1.16.18</lombok.version>
        <!--Apache 相关组件  End-->

        <!--日志相关组件  Begin-->
        <slf4j.version>1.8.0-beta0</slf4j.version>
        <logback.version>1.2.3</logback.version>
        <!--日志相关组件  End-->

        <!--Dubbo和Zookeeper  Begin-->
        <dubbo.version>2.5.8</dubbo.version>
        <netty-all.version>4.1.19.Final</netty-all.version>
        <zookeeper.version>3.4.11</zookeeper.version>
        <zkclient.version>0.10</zkclient.version>
        <!--Dubbo和Zookeeper  End-->

        <!--Google的组件  Begin-->
        <gson.version>2.8.2</gson.version>
        <guava.version>23.6-jre</guava.version>
        <!--Google的组件  End-->

        <!--文件上传组件  Begin-->
        <commons-fileupload.version>1.3.3</commons-fileupload.version>
        <commons-io.version>2.6</commons-io.version>
        <commons-codec.version>1.11</commons-codec.version>
        <!--文件上传组件  End-->

        <!--其它组件  Begin-->
        <aspectj.version>1.8.13</aspectj.version>
        <servlet.version>4.0.0</servlet.version>
        <javassist.version>3.22.0-GA</javassist.version>
        <mockito-core.version>2.13.0</mockito-core.version>
        <jackson.version>2.9.3</jackson.version>
        <jstl.version>1.2</jstl.version>
        <standard.version>1.1.2</standard.version>
        <!--其它组件  End-->

        <!--Maven 插件  Begin-->
        <maven-resources-plugin.version>3.0.2</maven-resources-plugin.version>
        <maven-compiler-plugin.version>3.7.0</maven-compiler-plugin.version>
        <maven-source-plugin.version>3.0.1</maven-source-plugin.version>
        <!--Maven 插件  End-->
        <updateReleaseInfo>true</updateReleaseInfo>
    </properties>


    <!--增加了模块之后，自动生成模块配置-->
    <modules>
        <module>lm-api</module>
        <module>lm-model</module>
        <module>lm-dao</module>
        <module>lm-service</module>
        <module>lm-mapping</module>
        <module>lm-core</module>
        <module>lm-web</module>
    </modules>


    <dependencyManagement>
        <!--凡是继承该pom的子项目，都可以继承以下所有jar包组件 -->
        <dependencies>

            <!--JUnit是编写可重复测试的简单框架。它是单元测试框架的xUnit体系结构的一个实例。-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>

            <!--JavaEE-API-->
            <dependency>
                <groupId>javax</groupId>
                <artifactId>javaee-api</artifactId>
                <version>${javaee-api.version}</version>
                <scope>provided</scope>
            </dependency>

            <!--Spring Framework 的功能被组织成了 20 来个模块。这些模块分成 Core Container, Data Access/Integration, Web, AOP (Aspect Oriented Programming), Instrumentation, Messaging, 和 Test-->
            <!--Spring中文文档：https://www.gitbook.com/book/waylau/spring-framework-4-reference/details-->

            <!--核心容器-->
            <!--Core Container 由 spring-core, spring-beans, spring-context, spring-context-support, 和 spring-expression (Spring Expression Language) 5个模块组成。-->
            <!--spring-core 和 spring-beans 提供框架的基础部分，包括 IoC 和 Dependency Injection 功能。BeanFactory 是一个复杂的工厂模式的实现。不需要可以编程的单例，并允许您将配置和特定的依赖从你的实际程序逻辑中解耦。spring-beans是所有应用都要用到的，它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI支持，引入spring-core.jar及spring- beans.jar文件就可以了。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>commons-logging</groupId>
                        <artifactId>commons-logging</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
                <type>pom.sha256</type>
            </dependency>

            <!--Context (spring-context) 模块建立且提供于在Core 和 Beans 模块的基础上，它是一种在框架类型下实现对象存储操作的手段，有一点像 JNDI 注册。Context 继承了 Beans 模块的特性，并且增加了对国际化的支持（例如用在资源包中）、事件广播、资源加载和创建上下文（例如 一个 Servlet 容器）。Context 模块也支持例如 EJB，JMX 和基础远程这样的 JavaEE 特性。ApplicationContext 是 Context 模块的焦点。spring-context-support 提供对常见第三方库的支持集成进 Spring 应用上下文，如缓存 (EhCache, Guava, JCache), 通信 (JavaMail), 调度 (CommonJ, Quartz) 和 模板引擎 (FreeMarker, JasperReports, Velocity)。spring-context为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI所需的全部类，UI方面的用来与模板（Templating）引擎如 Velocity、FreeMarker、JasperReports集成的类，以及校验Validation方面的相关类。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!--spring-context-support 提供对常见第三方库的支持集成进 Spring 应用上下文，如缓存 (EhCache, Guava, JCache), 通信 (JavaMail), 调度 (CommonJ, Quartz) 和 模板引擎 (FreeMarker, JasperReports, Velocity)。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!--spring-expression 模块提供了一个强大的Expression Language（表达式语言）用来在运行时查询和操作对象图。这是作为JSP2.1 规范所指定的统一表达式语言（unified EL）的一种延续。这种语言支持对属性值、属性参数、方法调用、数组内容存储、收集器和索引、逻辑和算数操作及命名变量，并且通过名称从 Spring 的控制反转容器中取回对象。表达式语言模块也支持 List 的映射和选择，正如像常见的列表汇总一样。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-expression</artifactId>
                <version>${spring.version}</version>
            </dependency>


            <!--AOP 及 Instrumentation-->
            <!--spring-aop 模块提供 AOP Alliance-compliant（联盟兼容）的面向切面编程实现，允许你自定义，比如，方法拦截器和切入点完全分离代码。使用源码级别元数据的功能，你也可以在你的代码中加入 behavioral information (行为信息)，在某种程度上类似于 .NET 属性。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!--单独的 spring-aspects 模块提供了集成使用 AspectJ。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!--spring-instrument 模块提供了类 instrumentation 的支持和在某些应用程序服务器使用类加载器实现。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-instrument</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!--spring-instrument-tomcat 用于 Tomcat Instrumentation 代理。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-instrument-tomcat</artifactId>
                <version>${spring-instrument-tomcat.version}</version>
            </dependency>


            <!--Messaging 消息-->
            <!--Spring Framework 4 包含了 spring-messaging 模块，从 Spring 集成项目中抽象出来，比如 Message, MessageChannel, MessageHandler 及其他用来提供基于消息的基础服务。该模块还包括一组消息映射方法的注解，类似于基于编程模型 Spring MVC 的注解。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-messaging</artifactId>
                <version>${spring.version}</version>
            </dependency>


            <!--数据访问/集成-->
            <!--Data Access/Integration 层由 JDBC, ORM, OXM, JMS, 和 Transaction 模块组成。-->
            <!--spring-jdbc 模块提供了不需要编写冗长的JDBC代码和解析数据库厂商特有的错误代码的JDBC-抽象层。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!--spring-tx 模块的支持可编程和声明式事务管理，用于实现了特殊的接口的和你所有的POJO类（Plain Old Java Objects）。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!--spring-orm 模块提供了流行的 object-relational mapping（对象-关系映射）API集成层，其包含 JPA，JDO，Hibernate。使用ORM包，你可以使用所有的 O/R 映射框架结合所有Spring 提供的特性，比如前面提到的简单声明式事务管理功能。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-orm</artifactId>
                <version>5.0.2.RELEASE</version>
            </dependency>

            <!--spring-oxm 模块提供抽象层用于支持 Object/XML mapping （对象/XML映射）的实现,如 JAXB、Castor、XMLBeans、JiBX 和 XStream 等。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-oxm</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!--spring-jms 模块（Java Messaging Service）包含生产和消费信息的功能。 从 Spring Framework 4.1 开始提供集成 spring-messaging 模块。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jms</artifactId>
                <version>5.0.2.RELEASE</version>
            </dependency>



            <!--Web 层-->
            <!--Web 层由 spring-web, spring-webmvc, spring-websocket, 和 spring-webmvc-portlet 组成 。-->
            <!--spring-web 模块提供了基本的面向 web 开发的集成功能，例如多方文件上传、使用 Servlet listeners 和 Web 开发应用程序上下文初始化 IoC 容器。它也包含 HTTP 客户端以及 Spring 远程访问的支持的 web 相关的部分。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!--spring-webmvc 模块（也被称为 Web Servlet 模块）包含 Spring 的model-view-controller （模型-视图-控制器（MVC）和 REST Web Services 实现的Web应用程序。Spring 的 MVC 框架提供了domain model（领域模型）代码和 web form (网页) 之间的完全分离，并且集成了 Spring Framework 所有的其他功能。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!--spring-webmvc-portlet 模块（也被称为 Web-Portlet 模块）提供了MVC 模式的实现是用一个 Portlet 的环境和 spring-webmvc 模块功能的镜像。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc-portlet</artifactId>
                <version>${spring-webmvc-portlet.version}</version>
            </dependency>

            <!--Test 测试层-->
            <!--spring-test 模块支持通过组合 JUnit 或 TestNG 来进行单元测试和集成测试 。它提供了连续的加载 ApplicationContext 并且缓存这些上下文。它还提供了 mock object（模仿对象），您可以使用隔离测试你的代码。-->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
                <scope>test</scope>
            </dependency>

            <!--Mockito 是一个强大的用于 Java 开发的模拟测试框架, 通过 Mockito 我们可以创建和配置 Mock 对象, 进而简化有外部依赖的类的测试.
使用 Mockito 的大致流程为:创建外部依赖的 Mock 对象, 然后将此 Mock 对象注入到测试类中······>执行测试代码······>校验测试代码是否执行正确.-->
            <!--http://site.mockito.org/-->
            <!--中文文档：https://github.com/hehonghui/mockito-doc-zh-->
            <dependency>
                <groupId>org.mockito</groupId>
                <artifactId>mockito-core</artifactId>
                <version>${mockito-core.version}</version>
                <scope>test</scope>
            </dependency>

            <!--数据库链接组件-->
            <!--Druid是一个监控而生的数据库连接池(JDBC组件库)，包括数据库连接池、SQL Parser等组件。DruidDataSource是最好的数据库连接池。-->
            <!--https://github.com/alibaba/druid-->
            <!--中文文档：https://github.com/alibaba/druid/wiki/首页 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <!--GitHub地址：https://github.com/mysql/mysql-connector-j-->
            <!--官方文档(英文)：https://dev.mysql.com/doc/connector-j/5.1/en/-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql-connector-java.version}</version>
            </dependency>


            <!--MyBatis-->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-parent</artifactId>
                <version>30</version>
                <type>pom</type>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <!--[MyBatis-Spring]中文文档地址：http://www.mybatis.org/spring/zh/index.html-->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>${mybatis-spring.version}</version>
            </dependency>
            <!-- MyBatis 自动生成实体类、DAO接口和Mapping插件 -->
            <dependency>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator</artifactId>
                <version>${mybatis-generator-core.version}</version>
                <type>pom</type>
            </dependency>
            <dependency>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-core</artifactId>
                <version>${mybatis-generator-core.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>${mybatis-generator-core.version}</version>
            </dependency>

            <!--org.mybatis.maven 组套件-->
            <!--Maven MyBatis Migration Plugin是一个Apache的Maven2插件，旨在融入Maven的生命周期，MyBatis3迁移工具。MyBatis3 Migration Schema是一种工具，可以帮助您管理数据库架构更改。-->
            <dependency>
                <groupId>org.mybatis.maven</groupId>
                <artifactId>migrations-maven-plugin</artifactId>
                <version>1.1.3</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis.maven</groupId>
                <artifactId>maven-migration-plugin</artifactId>
                <version>1.0.0</version>
            </dependency>


            <!--MyBatis 通用 Mapper-->
            <!--文档地址：https://mapperhelper.github.io/docs/-->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper</artifactId>
                <version>${mapper.version}</version>
            </dependency>
            <!--Mybatis 通用 Mapper 的扩展 weekend-->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-weekend</artifactId>
                <version>1.0.0</version>
            </dependency>
            <!--Mybatis 排序插件-->
            <!--GitHub地址：https://github.com/abel533/OrderByHelper -->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>orderby-helper</artifactId>
                <version>0.0.2</version>
            </dependency>
            <!--MyBatis 分页插件-->
            <!--GitHub地址：https://github.com/pagehelper/Mybatis-PageHelper-->
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper</artifactId>
                <version>${pagehelper.version}</version>
            </dependency>

            <!--Apache-->
            <!--BeanUtils主要提供了对于JavaBean进行各种操作。在一般的写bean组件的时候，都必须要写setter和getter方法，当然假如我们事先已经知道bean的相关属性和方法，写bean是比较简单的，但是组件太多的时候，重复编写经常是枯燥乏味令人厌烦的。但当有些时候我么需要调用动态对象的属性的时候，我们应该怎么来设定和获取对象的属性呢？BeanUtils就可以帮助我们来解决这个问题。它需要Jakarta-Commons -Collections包和Jakarta-Commons -logging包的支持。-->
            <!--参考学习：http://www.cnblogs.com/zhangyi85/archive/2009/04/22/1441341.html-->
            <dependency>
                <groupId>commons-beanutils</groupId>
                <artifactId>commons-beanutils</artifactId>
                <version>${commons-beanutils.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>commons-logging</groupId>
                        <artifactId>commons-logging</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <!--commons-collections4 是BeanUtils的依赖工具包。BeanUtils中还有其他一些依赖Commons Collections（例如BeanMap）的类-->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-collections4</artifactId>
                <version>${commons-collections4.version}</version>
            </dependency>

            <!--HttpClient是Apache Jakarta Common下的子项目，用来提供高效的、最新的、功能丰富的支持HTTP协议的客户端编程工具包，并且它支持HTTP协议最新的版本和建议。HttpClient已经应用在很多的项目中，比如Apache Jakarta上很著名的另外两个开源项目Cactus和HTMLUnit都使用了HttpClient。-->
            <dependency>
                <groupId>org.apache.httpcomponents</groupId>
                <artifactId>httpclient</artifactId>
                <version>${httpclient.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>commons-logging</groupId>
                        <artifactId>commons-logging</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>

            <!--日子处理方式：Logback + SLF4j-->
            <!-- SLF4J ，即简单日志门面（Simple Logging Facade for Java），按照官方的说法，SLF4J 是一个用于日志系统的简单Facade ，允许最终用户在部署其应用时使用其所希望的日志系统。SLF4J是一个简单的日志系统外观，它允许终端用户在部署时植入所需日志系统。slf4j与logback集成：需要的jar包：slf4j-api、logback-core、logback-classic(已含有对slf4j的集成包)-->
            <!--参考文档：http://www.xuetimes.com/archives/475
                        http://www.importnew.com/21486.html -->
            <!--SLF4J-logback 配置  Begin-->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <!-- 强制使用 logback的绑定 -->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>${logback.version}</version>
            </dependency>
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-classic</artifactId>
                <version>${logback.version}</version>
            </dependency>
            <!--下面是强制配置，不是必须的，但是为了以后不出现bug，在此一次性配置完成-->
            <!-- 强制使用 logback的绑定,这里去除对log4j 的绑定 -->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>99.0-does-not-exis</version>
            </dependency>
            <!-- slf4j 的桥接器,将第三方类库对 log4j 的调用 delegate 到 slf4j api 上。这个桥接器是自己做的,主要是我们依赖的类库存在很多硬编码的引用 -->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>log4j-over-slf4j</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>jcl-over-slf4j</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <!-- 强制排除 log4j 的依赖,全部 delegate 到 log4j-over-slf4j 上 -->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>99.0-does-not-exist</version>
            </dependency>
            <dependency>
                <groupId>apache-log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>999-not-exist</version>
            </dependency>
            <!--SLF4J-logback 配置  Begin-->

            <!--dubbo 单点登录插件-->
            <!--Dubbo是Alibaba开源的分布式服务框架，它最大的特点是按照分层的方式来架构，使用这种方式可以使各个层之间解耦合（或者最大限度地松耦合）。Dubbo使得应用可通过高性能的RPC实现服务的输出和输入功能，可以和Spring框架无缝集成。-->
            <!--官方手册：https://www.gitbook.com/@dubbo -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>dubbo</artifactId>
                <version>${dubbo.version}</version>
                <exclusions>
                    <exclusion>
                        <artifactId>spring</artifactId>
                        <groupId>org.springframework</groupId>
                    </exclusion>
                    <exclusion>
                        <artifactId>netty</artifactId>
                        <groupId>org.jboss.netty</groupId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>io.netty</groupId>
                <artifactId>netty-all</artifactId>
                <version>${netty-all.version}</version>
                <scope>compile</scope>
            </dependency>



            <!--Zookeeper 分布式服务框架，管理分布式环境中的数据-->
            <dependency>
                <groupId>org.apache.zookeeper</groupId>
                <artifactId>zookeeper</artifactId>
                <version>${zookeeper.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>log4j</groupId>
                        <artifactId>log4j</artifactId>
                    </exclusion>
                </exclusions>
                <type>pom</type>
            </dependency>
            <dependency>
                <groupId>com.101tec</groupId>
                <artifactId>zkclient</artifactId>
                <version>${zkclient.version}</version>
                <exclusions>
                    <exclusion>
                        <groupId>log4j</groupId>
                        <artifactId>log4j</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>

            <!--Jackson是一个简单基于Java应用库，Jackson可以轻松的将Java对象转换成json对象和xml文档，同样也可以将json、xml转换成Java对象。Jackson所依赖的jar包较少，简单易用并且性能也要相对高些，并且Jackson社区相对比较活跃，更新速度也比较快。-->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>${jackson.version}</version>
            </dependency>
            <!--下面两个是Jackson的两个依赖包-->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-core</artifactId>
                <version>${jackson.version}</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-annotations</artifactId>
                <version>${jackson.version}</version>
            </dependency>


            <!--AspectJ是在PARC为Java编程语言创建的面向方面编程（AOP）扩展。它可以在Eclipse Foundation开源项目中使用，既可以独立使用，也可以集成到Eclipse中。AspectJ通过强调最终用户的简单性和可用性，已经成为AOP广泛使用的事实标准。它使用类似于Java的语法，并且包含了自2001年首次公开发布以来用于显示横切结构的 IDE集成。-->
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjrt</artifactId>
                <version>${aspectj.version}</version>
            </dependency>
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>${aspectj.version}</version>
            </dependency>

            <dependency>
                <groupId>aopalliance</groupId>
                <artifactId>aopalliance</artifactId>
                <version>1.0</version>
            </dependency>

            <!--Java Servlet是Java Enterprise Platform中的基础Web规范。开发人员可以使用Servlet API构建Web应用程序来与请求/响应工作流进行交互。该项目提供了有关Java Servlet规范的持续开发的信息。-->
            <!--官网：https://javaee.github.io/servlet-spec/-->
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>${servlet.version}</version>
                <scope>provided</scope>
            </dependency>

            <!--Javassist是一个处理Java字节码的类库。Java字节码存储在称为类文件的二进制文件中。每个类文件都包含一个Java类或接口。该类Javassist.CtClass是类文件的抽象表示。一个CtClass（编译时类）对象是处理一类文件的句柄。-->
            <dependency>
                <groupId>org.javassist</groupId>
                <artifactId>javassist</artifactId>
                <version>${javassist.version}</version>
            </dependency>

            <!--Google的一些实用jar包-->
            <!--Gson是一个Java库，可用于将Java对象转换为JSON表示。它也可以用来将JSON字符串转换为等效的Java对象。Gson可以使用任意的Java对象，包括你没有源代码的预先存在的对象。-->
            <dependency>
                <groupId>com.google.code.gson</groupId>
                <artifactId>gson</artifactId>
                <version>${gson.version}</version>
            </dependency>
            <dependency>
                <groupId>com.google.code.gson</groupId>
                <artifactId>gson-parent</artifactId>
                <version>${gson.version}</version>
                <type>pom</type>
            </dependency>

            <!--Guava是一组核心库，包括新的集合类型（如multimap和multiset），不可变集合，图形库，函数类型，内存中缓存以及用于并发，I / O，散列，基元的API /实用程序，反射，字符串处理等等！-->
            <!--GitHub地址：https://github.com/google/guava -->
            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>${guava.version}</version>
            </dependency>

            <!--lombok 提供了简单的注解的形式来帮助我们简化消除一些必须有但显得很臃肿的 java 代码。特别是相对于 POJO
            常用的 lombok 注解：
                @Data   ：注解在类上；提供类所有属性的 getting 和 setting 方法，此外还提供了equals、canEqual、hashCode、toString 方法
                @Setter：注解在属性上；为属性提供 setting 方法
                @Getter：注解在属性上；为属性提供 getting 方法
                @Log4j ：注解在类上；为类提供一个 属性名为log 的 log4j 日志对象
                @NoArgsConstructor：注解在类上；为类提供一个无参的构造方法
                @AllArgsConstructor：注解在类上；为类提供一个全参的构造方法
            -->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <scope>provided</scope>
            </dependency>

            <!--JavaServer Pages标准标签库（JSTL）将简单标签封装为许多Web应用程序通用的核心功能。JSTL支持常见的结构化任务，如迭代和条件，用于处理XML文档的标签，国际化标记和SQL标签。它还提供了一个将现有定制标签与JSTL标签集成的框架。
            使用方法：
            <%@ taglib prefix="c"
                       uri="http://java.sun.com/jsp/jstl/core" %>
            其中，核心标签库：prefix="c"
                 格式化标签：prefix="fmt" (uri中也改为"fmt")
                 SQL标签库：prefix="sql" (uri中也改为"sql")
                 XML 标签： prefix="x" (uri中也改为"xml")
                 JSTL函数： prefix="fn" (uri中也改为"functions")
            -->
            <!--JSTL标准标签库-->
            <dependency>
                <groupId>javax.servlet.jsp.jstl</groupId>
                <artifactId>jstl</artifactId>
                <version>${jstl.version}</version>
            </dependency>
            <!--核心标签库组件-->
            <dependency>
                <groupId>taglibs</groupId>
                <artifactId>standard</artifactId>
                <version>${standard.version}</version>
            </dependency>
            <!--XML的支持组件-->
            <dependency>
                <groupId>org.apache.xerces</groupId>
                <artifactId>xercesImpl</artifactId>
                <version>2.9.1</version>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>xalan</groupId>
                <artifactId>xalan</artifactId>
                <version>2.7.2</version>
            </dependency>


            <!-- 文件上传组件包 -->
            <dependency>
                <groupId>commons-fileupload</groupId>
                <artifactId>commons-fileupload</artifactId>
                <version>1.3.3</version>
            </dependency>
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>2.5</version>
            </dependency>
            <dependency>
                <groupId>commons-codec</groupId>
                <artifactId>commons-codec</artifactId>
                <version>1.9</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!--到此处，所有常用的依赖包已经完全配置完成！！！-->


    <!--································································-->
    <!--································································-->
    <!--POM 4.0的一个新功能是项目能够根据所在的环境来改变设置。profile元素包含两个任选的activation（a profile trigger）和设定变化的向POM制成如果所选择的文档已被激活。例如，为测试环境构建的项目可能会指向与最终部署不同的数据库。或者根据所使用的JDK版本，可能会从不同的存储库中提取依赖关系。配置文件的元素如下：-->
    <!--
    <profiles>
        <profile>
            <id>local</id>
            <build>
                <resources>
                    <resource>
                        <directory>${profiles.dir}/local</directory>
                    </resource>
                </resources>
            </build>
        </profile>

        <profile>
            <id>dev</id>
            <build>
                <resources>
                    <resource>
                        <directory>${profiles.dir}/dev</directory>
                    </resource>
                </resources>
            </build>
        </profile>
    </profiles>
    -->
    <!--································································-->
    <!--································································-->


    <!--
    根据POM 4.0.0 XSD中，构建元件在概念上被分为两个部分：有一个BaseBuild其中包含所述一组常见的两种元素的类型建立元件（下的顶层构建元件项目和下生成元件的配置文件如下所述）; 还有Build类型，它包含BaseBuild集合以及顶层定义的更多元素。让我们从分析两者之间的共同点开始。
    注：这些不同的 构建 元素可能被称为“项目构建”和“构建配置文件”。
    -->
    <!--“Profile Build”包含“Project Build”元素的一个子集
     “Profile Build”包含“Project Build”元素的一个子集-->
    <build>
        <finalName>${center.project.name}</finalName>

        <!--Maven 插件所需组件  Begin-->
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>${maven-resources-plugin.version}</version>
                <configuration>
                    <encoding>${encoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven-compiler-plugin.version}</version>
                <configuration>
                    <source>${jdk.version}</source>
                    <target>${jdk.version}</target>
                    <encoding>${encoding}</encoding>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-source-plugin</artifactId>
                <version>${maven-source-plugin.version}</version>
                <configuration>
                    <attach>true</attach>
                </configuration>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
        <!--Maven 插件所需组件  End-->

        <!--设置资源文件夹-->
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

    <!--下面是项目的其它信息-->
    <issueManagement>
        <system>github</system>
        <url>https://github.com/jonny6015/lmsite/issues</url>
    </issueManagement>
    <scm>
        <url>https://github.com/jonny6015/lmsite</url>
        <connection>scm:https://github.com/jonny6015/lmsite</connection>
        <developerConnection>scm:svn:https://github.com/jonny6015/lmsite</developerConnection>
    </scm>
    <mailingLists>
        <mailingList>
            <name>LMS User Mailling List</name>
            <subscribe>lmsite-subscribe AT gmail DOT com</subscribe>
            <unsubscribe>lmsite-unsubscribe AT gmail DOT com</unsubscribe>
            <post>lmsite AT gmail DOT com</post>
            <archive>http:/gmail.google.com/jonny0624</archive>
        </mailingList>
    </mailingLists>
    <developers>
        <developer>
            <id>lmsite.cn</id>
            <name>The LmSite Project Contributors</name>
            <email>jonny0624@gmail.com</email>
            <url>http://lmsite.cn</url>
            <organization>The LmSite Project</organization>
            <organizationUrl>http://lmsite.cn</organizationUrl>
        </developer>
    </developers>
</project>