1、maven入门
1.1 maven :项目管理工具
-- 今日必须掌握的东西：
1.项目的生命周期(命令)：
* 1.clean(清除缓存)
* 2.default（一整套生命周期）
* 3.site（这个几乎不用）
2.maven的安装配置。
* 配置环境变量:先系统变量添加maven，再在Path添加，并且确保环境变量中有JAVA_HOME;
3.maven仓库的类型：本地仓库/私服/中央仓库
* 1.启动maven工程时，首先会通过jar包的坐标在系统盘找本地仓库，如果本地仓库没有，在有网络的情况下，会自动从中央仓库下载jar包，如果找不到则会报错。
* 2.先从本地找，找不到找远程仓库（私服），如果有网络则通过网络在中央仓库下载，或者用户上传到远程仓库。 （基本上公司里都是在私服里找，不通过中央仓库）
* 在以上两种情况能第一次完成部署后，以后需要相同的jar包，会直接在仓库找，因为前面已经缓存下载到了本地仓库了。
4.测试，项目管理等。
1.2 今日内容
Manve的特点：
1. 核心功能之一：依赖管理：maven工程对jar包的管理过程 -- pom.xml文件可以导入jar包，配置maven的插件 jar包都在deoendencies标签中管理
* 使用Maven构建工程，jar包不在项目中，可以极大的减少磁盘空间。
* 使用Maven构建工程，jar包放在仓库中，maven通过jar包的坐标找到。
2.核心功能之二： 一键构建：
* 默认生命周期：compile(编译)，test(测试)，package(打包)，install（安装），deploy（发布）
* 清理生命周期：clean
* 当执行后面的功能，前面的都会执行。比如：执行发布的时候，会自动的执行编译，测试，打包，安装等功能。
1.Maven的作用：
1.导入jar包
2.单元测试
3.打包
2.Maven的一键构建:使用maven自身的tomcat插件完成一键构建；
1.构建过程：清理-> 编译-> 运行->测试 ->部署
* 英文： clean(清理)->validata（验证）->compolie->test(测试)->package（打包）->varify->install->site->deploy
2.maven中的插件：tomcat插件 --> 只要配置好了tomcat的插件就可以直接部署，直接在浏览器上查看。
3.maven项目目录结构：
1.核心代码部分:
* src/main/java 目录
2.配置文件部分：
* src/main/resources
3.测试代码部分：
* src/test/java
4.测试配置文件：
* src/test/resources
5.页面资源,js,css,图片等：
* src/main/webapp
-- 为什么用maven的项目架构？
* 每个工具如idea等的由不同的厂商提供的，每个软件的目录文件不一样，会导致每个人的项目结构不统一。所以使用maven的项目结构能够被每一个工具所支持，那么就可以使项目架构统一，提高工作效率。
4.maven生命周期中的命令（重要的五个）：
1.清除生命周期：
* 清除：clean -- 使用较多
2.default生命周期（编译，测试，打包，发布）：
* 编译： compile -- 使用较多
* 测试: test （没用）
* 打包： package 1.把代码进行编译 2.把web打成jar包，war包等 -- 使用较多
* 发布： install 1.把代码进行编译 2.把web打成jar包，war包等 3.把jar包发布到本地仓库中 发布项目需要借助tomcat插件发布。
* 当执行到后面的命令的时候，前面的命令会自动执行，clean是清除生命周期。
5.maven项目
1.依赖管理
1.项目对象模型（POM） -- pom.xml
* 项目自身信息：
* 项目运行所依赖的jar包信息
* 项目运行环境信息
2.依赖管理模型（Dependency）： -- 仓库
* 公司组织的名称
* 项目名
* 版本号
* 本地仓库更多信息
2.生命周期
1.默认生命周期：
* compile,test,package,install,deploy
* 每一次构建项目的命令都对应了maven底层一个插件
* idea对Maven的支持只能算一般，在新建maven项目的时候尽可能的不要使用骨架，因为使用骨架如果出现与本地文件的兼容出错问题，将使项目无法创建。
* 在导入servlet依赖的时候，注意版本要在3.0以上，因为servlet3.0以下不支持注解。
* maven支持一键构建，所以在部署项目的时候有自己的tomcat插件，但是编译通过后，运行时硬盘上就有了两个tomcat，所以会出现tomcat冲突。导致异常。解决办法：<scope>provided</scope>给tomcat设置作用域，在测试，servlet.jsp等包坐标也要加作用域。
* 如果要正确部署，需要将packing的标签jar改为war。
* 用tomcat7，因为tomcat插件在中央仓库没有
6.案列：
* JDBC
1.注册驱动：
class.forName("com.mysql.jdbc.Driver");
2.获取连接：
Connection con= DriverManager.getConnetion("jdbc:mysql://localhost:3306/数据库名称","root","root");
3.获取执行sql的对象
statement=con.createStatement()
preparedStatement=con.preparedStatement()
4.执行sql
* 增删改
stateMent.executeUpdate();
* 查询
ResultSet rs= stateMent.excuteQuery();
5.遍历结果集
while(rs.next()){
rs.getObject("列名")
re.getObject(1)
}
6.释放资源：
依次关闭资源。
总结：
1. 使用maven创建web项目！！
2. 将pom.xml文件中修改打包方式 以下四步都是在pom.xml中完成
* <packaging>war</packaging>
* 引入javax.servlet 导包
* 引入.servlet.jsp 导包
* 引入jdk1.8 或者1.9,引入tomcat插件1.7
3.完善目录结构：
* 将目录结构修改成一个web目录，在main目录下创建webapp目录，通知指定目录类型
* webapp目录：Mouduls->web->添加，将webapps属性改为web
* 代码目录类型：右键目录->MARK Directory As --> Sources Root
* 资源目录类型：右键目录->MARK Directory As --> Resources Root
4.可以在src/main/java目录下开始写java代码，webapp目录可以放web页面资源，Resources可以放配置文件
注意：
* 在3 的过程中为了防止jar包冲突，添加scope,里面给域的值。
* <packaging>war/jar/pom[]</packaging>
* mysql驱动导包给坐标时，scope设置为runtime
* 要想从数据库中取出数据，必须有四个属性：
* 1.数据库驱动，连接数据库的地址，数据库的账号，数据库的密码。
1.3 创建Maven的java项目：
1. 创建新的工程
2. 选择Maven
3. 可选择骨架或直接创建
4. 补全内容
5. 创建完成后补全需要的包
6. 给一些特定的包属性，如java，resources，webapps,test等...
2、maven高级
2.1 maven高级应用
1. maven基础回顾
2. maven传统的web工程做一个数据查询操作
3. maven工程拆分与聚合的思想
4. 把第二阶段做好的web工程修改成maven拆分与聚合的形式。
5. 私服【远程仓库】
6. 如何安装第三方jar包。【把第三方jar包安装到本地仓库，把第三方jar包安装到私服】
2.2 maven基础知识回顾
1. maven是一个项目管理工具
2. 核心功能：
1. 依赖管理：
* maven对项目jar包的管理过程。传统工程我们直接把jar包放置在项目中。
* maven工程真正的jar包放置在仓库中，项目中只用放置jar包的坐标
2. 一键构建：
* maven自身集成了tomcat插件，可以对项目进行编译，测试，打包，安装，发布等操作。
* maven常用命令：clean ,complie(编译),test,package,install(把包安装到本地仓库),deploy（把做好的项目直接打包上传到私服）。
* maven三套生命周期：
1. 清理生命周期：clean
2. 默认生命周期：complie~install
3. 站点生命周期
3. 仓库的种类：
1. 本地仓库
2. 远程仓库【私服】：公司区域网内的仓库
3. 中央仓库【本地的环境只要可以联网就直接连上了中央仓库】
4. 关系：
* 当我们启动了一个maven工程的时候，maven工程会通过pom文件中jar包的坐标去本地仓库找对应jar包。
* 默认情况下，如果本地仓库没有对应jar包，maven工程会自动去中央仓库下载jar包到本地仓库。
* 在公司汇总，如果本地没有对应jar包，会先从私服下载jar包。
* 如果私服没有jar包，可以从中央仓库下载，也可以从本地上传到私服。
2.3 案例准备
1. 环境准备
1. 创建数据库，执行建表语句和插入表语句 [可以直接复制语句，也可以直接执行数据库脚本-maven高级-资料-items.sql]
2. 创建maven工程，补齐目录名字和对应属性；java,resources,webapp,test
3. 找到web配置头声明，打开web.xml加入到<web-app>标签内
4. pom.xml中导入坐标 [spring-context] /导入了核心包，它会附带其他依赖包；
* 导入时需要注意的地方：
1. maven工程咬导入jar包的坐标，就必须要解决jar冲突；
-- 解决jar包冲突的方式一：
1. 声明优先原则：哪个jar包的坐标在靠上的位置，这个jar包就是先声明的，先声明的jar包坐标下的依赖包，可以优先进入项目中。
* maven导入jar包中的一些概念：
1. 直接依赖：项目中直接导入的jar包，就是该项目的直接依赖包
2. 传递依赖：项目中没有直接导入的jar包，可以通过项目直接依赖jar包传递到项目中。
-- 解决jar包冲突的方式二：
2. 路径近者优先原则。直接依赖路径比传递依赖路径近，那么最终项目进入的jar包会是路径近的直接依赖包
-- 解决jar包冲突的方式三：
3. 直接排除法。当我们要排除某个jar包下的依赖包，在配置exclusions标签的时候，内部可以不写版本号，因此此时依赖包使用的版本和默认版本一样。
* <exclusions>
* <exclusion>
* <groupId>org.springframework</groupId>
* <artifactId>spring-core</artifactId>
* </exclusion>
* <exclusions>
-- 如果高版本和低版本的包同时存在，有可能低版本的包会将高版本的包覆盖掉，可能会出问题。[有些功能无法实现]
2. <dependencyManagenment>锁定jar包版本。 锁定版本的时候，需要重新复制一份，不能剪切。
1. maven工程是可以分父子依赖关系的。凡是依赖别的项目后，拿到的别的项目的依赖包，都属于传递依赖。
* 比如：当前A项目，被B项目依赖。那么我们A项目总所有jar包都会传递到B项目中。
2. B项目开发者，如果再再B项目总导入一套ssm框架的jar包，对于B项目是直接依赖。那么直接依赖的jar包就会把我们A项目传递过去的jar包覆盖掉。为了防止以上情况的出现。我们可以把A项目中主要jar包的坐标锁住，那么其他依赖该项目的项目中，即便是有同名jar包直接依赖，也无法覆盖。
3. 统一管理jar包版本，方便以后维护，以后修改版本的时候，只需要修改统一管理的地方，不需要每一处做修改。
2.3.1 dao层编写：
1. 创建java.com.itheima.domain.Items类
* public class Items{
* private Integer id;
* private String name;
* private Double price;
* privaete String pic;
* private Date createtime;
* private String detail;
* get,set方法
*
* }
2. 创建java.com.itheima.dao.ItemsDao接口
* public interface ItemsDao{
* public Items findById(Integer id);
* }
3. resources.com/itheima/dao.ItemsDao.xml
* 导入约束头部
* <mapper namespace="com.itheima.dao.ItemsDao">
* <select id="findById" parameterType="int" resultType="items">
* select * from items where id=#{id}
* </select>
* </mapper>
4. resources根目录下创建applicationContext.xml
* 导入约束
* <!--dao层配置文件开始-->
*
* <!-- 配置连接池-->
* <bean id="dateSource" class="com.alibaba.druid.pool.DruidDateSource">
* <property name="driverClassName" value="com.alibaba.druid.pool.DruidDateSource"/>
* <property name="url" value="jdbc:mysql:///maven"/>
* <property name="username" value="root"/>
* <property name="password" value="root"/>
* </bean>
* <!--配置生产SqlSession对象的工厂-->
* <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
* <property name="dateSource" ref="dataSource"/>
* <!--扫描pojo包，给包下所有pojo对象起别名-->
* <property name="typeAliasesPackage" value="com.itheima.domain"/>
* </bean>
* <!--扫描接口包路径，生成包下所有接口的代理对象，并且放入spring容器中-->
* <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
* <property name="basePackage" value="com.itheima.dao"/>
* <!--dao层配置文件结束-->
5. 测试dao，创建test.java.com.itheima.test.ItemsTest:
* public class ItemsTest{
* @Test
* public void findById(){
*
* ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
*
* ItemsDao itemsDao=ac.getBean(ithemsDao.class);
*
* Items items=itemsDao.findById();
* System.out.println(items.getName());
* }
* }
2.3.2 service 层编写
* 遵从原则：
* 自己写的类尽量使用注解
* 框架的类尽量使用配置文件
1. 创建main.java.com.itheima.service.ItemsService接口
* public interface ItemsService{
* public Items findById(Integer id);
* }
2. 创建main.java.com.itheima.service.impl.ItemsServiceImpl实现类
* public Items findById(Integer id){
* @Autowired
* private ItemsDao itemsDao;
* public Items findById(Integer id){
* return itemsDao.findById(id);
* }
* }
3. 打开applicationContext.xml
* <!-- dao层配置文件结束-->
* <!--service配置文件开始-->
* <!--组件扫描配置-->
* <context:component-scan base-package="com.itheima.service"/>
* <!--aop面向切面编程，切面就是切入点和通知的组合-->
* <!--配置事务管理器-->
* <bean id="transactionManager" class="org.springframework.jdbc.datesource.DataSourceTransactionManager">
* <property name="dateSource" ref="dateSource"/>
* </bean>
* <!--配置事务的通知-->
* <tx:advice id="advice">
* <tx:attributes>
* <tx:method name="save*" propagation="REQUIRED"/>
* <tx:method name="update*" propagation="REQUIRED"/>
* <tx:method name="delete*" propagation="REQUIRED"/>
* <tx:method name="find*" propagation="true"/>
*
* </tx:attributes>
* </tx:advice>
* <!--配置切面-->
* <aop:config>
* <aop:pointcut id="pointcut" expression="execution(* com.itheima.service.impl.*.*(..))"/>
* <aop：advisor advice-ref="advice" pointcut-ref="pointcut"/>
* <aop:config>
* <!--service配置文件结束-->
4. 测试：test.itemsTest:
* 注释掉前面dao层的测试
* public class ItemsTest{
*
* ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
* ItemsService itemsService =ac.getBean(ItemsService.class);
*
* Items items=itemsService.findById(1);
* System.out.println(items.getName());
* }
2.3.3 WEB层编写
1. 创建main.java.com.itheima.controller.ItemsController类：
* @Controller
* @RequestMapping("items")
* public class ItemsController{
* @Autowired
* private ItemsService itemsService;
* @RequestMapping("/findDetail")
* public String findDetail(Model model)
* Items items=itemsService.findById(1);
* model.addAttribute("",items);
* return "";
* }
* }
*
2.resources 创建springmvc.xml
1. 导入约束
2. 开始：
* <!--组件扫描-->
* <context:component-scan base-package="com.itheima.controller"/>
* <!--处理器映射器，处理器适配器-->
* <mvc:annotation-driven/>
* <!--视图解析器-->
* <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
* <property name="prefix" value="/WEB-INF/pages/"/>
* <property name="suffix" value=".jsp"/>
* </bean>
*
* <!--释放静态资源-->
* <mvc:default-servlet-handler/>
* </beans>
3.创建webapp.WEB-INF.pages.itemDatail.jsp;
* 页面接收数据
* 请自行编写
4. web.xml中配置
* <!--编码过滤器-->
* <filter>
* <filter-name>encoding</filter-name>
* <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
* <init-param>
* <param-name>encoding</param-name>
* <param-value>UTF-8</param-value>
* </init-param>
* </filter>
* <filter-mapping>
* <filter-name>encoding</filter-name>
* <url-pattern>
2.4 工程的拆分与聚合思想
1. 通过上面的案例可以看出：普通项目分三层：dao，service，controller
* 买家：买家要看到订单，必须要把数据库中订单查询出来。dao层的任务 系统：买家版
* 卖家：卖家要看到订单，必须要把数据库中订单查询出来。dao层的任务 系统：卖家版
2. 思想演变：
* 如果是一个传统的ssm框架整合的项目，我们要在每个项目中都放置一套ssm框架的jar包；
* 如果是maven的ssm工程，有十个项目我们也只需要一套jar包。真正项目中只放置jar的坐标即可。
* jar包内的是代码，我们写的每个层，每个项目也是代码，所谓的jar包和我们写的代码其实是一样的。
* 一份代码可重用和一份代码复制粘贴到不同地方的区别：如果修改维护的话，可重用的只需要修改一份，而复制粘贴几个地方，就要维护几个地方。
3. maven解决代码可重用和便于维护问题上是这样解决的：[拆分与聚合]
* maven把一个完整的项目，分成不同的独立模块，这些模块都有各自独立的坐标，哪个地方需要其中某个模块，就直接引用该模块的坐标即可。
* 今后如果公司开发一个新项目，我们先考虑的问题不是dao，service，utils，domain如何编写，我们要考虑的是：dao，service，utils，domain这些模块是否已经存在，如果存在直接引用。
* 以上说的就是maven拆分的思想；
* 我们可以把拆分零散的模块聚合到一起编写一个完整的项目，这就是maven聚合思想。
4. maven父子工程的创建
1. 父工程可以工程也可以模块，只需要一个pom.xml
1. 创建mvaen_day02_parent的project工程
2. 删除掉其他东西，留着.idea，maven_day02_parent.iml,pom.xml
2. 在该工程下创建新的项目，AId:maven_day02_dao文件，AId：maven_day02_service文件，Aid:maven_day02_web文件。
* 在父工程的pom.xml文件下出现了三个新的标签：
* <modules>
* <module>maven_day02_dao</module>
* <module>maven_day02_service</module>
* <module>maven_day02_web</module>
* </modules>
2.5 工程和模块的关系以及继承依赖的概念：
1. 工程和模块的区别：
* 工程不等于完整的项目，模块也不等于完整的项目，一个完整的项目看的是代码，代码完整，就可以说这是一个完整的项目，和此项目是工程和模块没有关系；
* 工程只能使用自己内部资源，工程天生是独立的。后天可以和其他工程或模块建立关联关系。
* 模块天生不是独立的，模块天生是属于父工程的。模块一旦创建，所有父工程的资源都可以使用。
* 父子工程之间，子模块天生集成父工程，可以使用父工程所有资源
* 子模块天生是没有关系的。
2. 使用，将工程内的模块项目放到本地仓库中，在pom.xml中导入坐标，即可使用；
* 父子工程之间不用建立关系，继承关系是先天的，不需要手动建立。
* 平级直接的引用叫依赖。 [依赖不是先天的，依赖是需要后天建立的]
2.6 父子工程的示例：
1. 在父工程中pom.xml导入子模块的坐标；
2. 对照直接依赖传递依赖的图可以看出：
1. dao和parent是直接依赖，作用域是compile
2. dao和junit是传递依赖，作用域是test [junit是在父工程中导入的junit，它的scope范围是test]
3. 通过以上两个对照表可以知道：junit传递到dao中已经不能使用了。
-- 总结：实际开发中，如果传递依赖丢失，表现形式就是jar包的坐标导不进去，我们的做法就是直接再导入一次。
3. 示例：
1. 创建maven_day02_parent父工程，保留.idea,maven_day02_parent.iml,pom.xml
2. 创建maven_day02_dao模块,补全相应的内容。
1. 创建src.main.java.itheima.domain,补全items实体类
2. 创建src.main.java.itheima.dao，补全itemsDao接口
3. 创建resource.com.itheima.dao，补全ithemsDao.xml
4. resources下创建spring.applicationContext-dao.xml,补全该配置文件 [只加入dao的部分]
3. 创建maven_day02_service
1. 在该模块下pom.xml导入dao模块
2. 创建java.com.itheima.service,导入接口Itemsservice，导入impl.ItemsServiceImpl;
3. 创建spring包，导入applicationContext-service.xml [删除里面所有关于dao的部分]
4. 创建maven_day02_web
1. 在该模块下pom.xml导入service模块和dao模块
2. 创建main.java.com.itheima.controller,补全该包下ItemsController
3. 创建resources.log4j.properties,resources.springmvc.xml并补全
4. 创建webapp.WEB-INF.pages.web.xml，并补全该web.xml内容
5. 创建WEB-INF.index.jsp
6. 发现web.xml内容中重新指定spring配置文件的路径报错：param-value标签显红色：
* 在resources下创建一个applicationContext.xml；
* <bean>
* 导入约束
* <import resource="classpath:spring/application-dao.xml">
* <import resource="classpath:spring/applicationContext-service.xml">
* </bean>
5.测试： [三种方式测试]
1. 方式一：启动父工程的tomcat 7 的run进行访问
2. 方式二：在Maven Projects下的maven_day02_parent下找到install双击打包安装到本地仓库，再找到maven_day02_web下的tomcat 7 下的tomcat7:run双击运行
3. 方式三：使用本地安装的tomcat：添加tomcat，点击Edit Configurations...->Tomcat Server->Local-> 在Deployment下添加[web模块即可]，exploded是热启动，war是打包启动 -> 点击启动；
4. 总结：三种启动方式，方式二模块下的项目需要自己安装到本地仓库，而父工程启动和导入的tomcat[方式一和方式二]不需要安装到本地仓库；
## 私服的安装和启动
1. 资料中一个是Linux的，一个是windows的，公司的私服一般在私服服务器上；
2. 步骤：
1. 解压：
* nexus-2.12.0-01:安装包
* sonatype-work: 私服
2. 打开nexus-2.12.0-01->bin->以管理员方式运行命令提示符->cd 该路径地址->
* 输入：nexus.bat uninstall [卸载]
* 或者输入：nexus.bat install [安装]
* 完成之后输入：nexus.bat start [运行]
3. 端口号为8081：路径：nexus-2.12.0-01-bundle->nexus-2.12.0-01->conf->nexus.properties中 【该配置文件下有该端口号，如果端口号被占用了，可以在该配置文件下进行修改。】
4. 测试：打开浏览器输入：localhost:8081/nexus/#welcome
5. 该地址需要登录：username:admin password:admin123 [这是默认账号密码]
6. 登录后，点击Repositories即可查看到本地私服内的文件了。
* Snapshots：测试版
* Releases：发行版
* 3rd party：第三方
* central： 中央仓库 地址：https://repol:maven.org/maven2/
* group:组：如果没有就从私服下，私服没有就从中央仓库下。
7. 远程仓库[私服]的物理地址：nexus-2.12.0-01-bundle->sonatype-work-nexus-storage
2.7 私服的应用
1. 设置登录密码：
1. 路径：apache-maven-3.5.2 ->conf ->settings.xml
2. 打开教案大纲复制server标签,在该server标签下添加内容：
* <servers>
* <server>
* <id>releases</id>
* <username>admin</username>
* <password>admin123</password>
* </server>
* <server>
* <id>snapshots</id>
* <username>admin</username>
* <password>admin123</password>
* </server>
* </servaers>
3. 在需要上传的模块下的pom.xml中添加该代码：
* <distributionManagement>
* <repository>
* <id>releases</id>
* <url>http://localhost:8081/nexus/content/repositories/releases/</url>
* </repository>
* <snapshotRepository>
* <id>snapshots</id>
* <url>http://localhost:8081/nexus/content/repositories/snapshots/</url>
* </snapshotRepository>
* </distributionMangement>
* </project>
* 正式对正式，测试对测试：公司中ip地址就不是localhost了，是需要改的。
2.将maven_day02_dao模块内容上传到私服：
1. 找到intellij idea的右边Maven Projects 下的maven_day02_dao的deploy，双击运行
2. 在nexus-2.12.0-01-bundle ->sonatype-work ->nexus ->storage ->snapshots下即可找到com的文件夹，该文件夹就是已经上传到私服的文件。
3. 这时候虽然已经上传成功了，但是不一定能下载成功。下载和上传的地址可能不一样；
1. 找到资料：下载jar包的配置，复制该一串代码。找到setting.xml，在标签<profiles>下复制该代码
2. 激活：在资料中找到该代码，复制到<profile>标签的外部的下面：
* <activeProfiles>
* <activeProfile>dev</activeProfile>
* </activeProfiles>
3. 这里的dev要与上面的配置下载地址的id的内容对应上；这里是都为dev；
4. 运行tomcat ：运行的时候，即便本地仓库中没有dao模块，但是它可以到中央仓库进行下载；
2.8 安装第三方jar包到私服
1. 安装到本地仓库：
1. 安装第三放jar包需要找到它的坐标，fastjson-1.1.37.jar的坐标在右边的mvn.txt中。
2. 如果安装其他的第三方jar包，将该文本的名字，版本号相应的修改即可。
2. 安装到私服：
1. 将文本的账号粘贴到maven中setting.xml中的账号位置，参照上面：servers标签内；
2. 参照文本；
2.9 安装阿里云镜像到conf/settings.xml文件中的标签中。
<mirror>
<id>nexus-aliyun</id>
<mirrorOf>central</mirrorOf>
<name>Nexus aliyun</name>
<url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>
扫一扫
98
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
