spring框架总结

时间 2019-12-14

标签 spring 框架总结栏目 Spring 繁體版

原文原文链接

2、过滤器 ......................................................................................................................................................... 2php

3、拦截器.......................................................................................................................................................... 3css

4、Spring MVC PK Struts2................................................................................................................................. 5html

Struts框架........................................................................................................................................................... 6前端

Struts2和struts1的比较.................................................................................................................................... 8java

Spring MVC......................................................................................................................................................... 14mysql

5、spring.......................................................................................................................................................... 19linux

6、Hibernate框架简述.............................................................................................................................. 29git

7、PL/SQL........................................................................................................................................................ 30程序员

Java项目通常发布在什么环境?...................................................................................................................... 31web

Java项目打包发布............................................................................................................................................ 31

九、Mybatis......................................................................................................................................................... 32

十、Svn使用教程............................................................................................................................................. 37

十一、项目流程.................................................................................................................................................... 63

关注数据流程的MVC框架（Struts1/2, WebWork, Spring MVC……）
关注数据关系的容器框架（Spring, GUICE……）
关注数据操做的持久层框架（Hibernate，IBatis……）

Spring框架总结

目的：解决企业应用开发的复杂性

功能：使用Javabean代替Ejb，并提供了更多的企业级应用

简答来讲：Java就是一个轻量级依赖注入（IOC）和面向切面的过程（aop）

1、监听器：

监听器其实是一个类，这个类实现了特定的接口，而后将这个类在web.xml文件中进行描述，这样服务器在启动的时候就能够实例化这个类，启动监听器。当范围内对象状态发生改变的时候，服务器自动调用监听器对象中的方法。例如统计在线人数。

在web监听器是Servlet规范中定义的一种特殊类，用于监听ServletContext，HttpSession，ServletRequest等域对象的建立、销毁、以及属性的变化等，能够在事件发生前、发生后处理。

监听器的用途：

一、统计在线人数

二、系统加载时进行信息的初始化

三、统计网站的访问量

四、跟Spring结合

4 监听器的分类

按监听的对象划分，能够分为监听

一、ServletContext对象

二、HttpSession对象

三、ServletRequest对象

按监听的事件划分

域对象自身的建立和销毁

一、域对象中属性的建立和消除

二、绑定到session中的某个对象的状态

三、因为不少监听的方式一致，所以咱们只考虑其中的HttpSession对象：

在web.xml中配置session超时

<session-config>

<session-timeout> 30 </session-timeout>

</session-config>

2、过滤器

是一个中间组件，用于拦截资源数据和目的数据之间的信息，用于过滤二者之间的传递的数据，其做用是阻止不想要的信息从一个点传递到另外一个点

开发过滤器的步骤

编码

必须实现javax.servlet.Filter接口

实现Filter中的三个方法 init() doFilter() destroy()

Init()方法是用来初始化过滤器的

doFilter()方法与Servlet中的service()方法同样由web容器调用

destroy()方法与Servlet中的destroy()方法同样也是最后一个由web容器调用的方法

须要注意的是doFilter()方法由于Filter中有一个而FilterChain中也有一个。

FilterChain中的doFilter()方法是将请求继续发送

编译

将类进行编译

部署

将编译好的class文件放到WEB-INF中的classes文件夹中

在web.xml文件中部署即 filter节点中有两个子节点 filter-name 中写上名称在节点filter-class中写上类名的路径

例如：

<filter-name>TestFilter</filter-name>

<filter-class>com.sun.TestFilter</filter-class>

<init-param>

<param-name>charset</param-name>

<param-value>gb2312</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>TestFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

还有一个与filter节点同级 filter-mapping语法和Servlet注册时是同样的方式

运行

在浏览器中访问的时候就能够避免一些问题，譬如说：直接登陆某个页面就不行了

过滤器的应用

认证过滤

对用户请求进行统一的认证

登陆和审核过滤

对用户的访问请求进行记录和审核

图像转换过滤

转换图像格式

数据压缩过滤

对用户发生的数据进行压缩，从而减小传输量

加密过滤

对请求和响应进行加密和解密处理

令牌过滤

XSLT过滤

MIME-type过滤

滤器链就是多个过滤器处理同一个请求

过滤器链执行的顺序是谁在前面注册谁就先执行

3、拦截器

拦截器在在流行的开源框架中很常见，依赖的技术就是Java的动态代理，拦截器就是一个类，这个类也包含方法，只是这个方法是个特殊方法，它会在目标方法调用以前“自动”执行

总结：
1.过滤器（Filter）：所谓过滤器顾名思义是用来过滤的，Java的过滤器可以为咱们提供系统级别的过滤，也就是说，能过滤全部的web请求，
这一点，是拦截器没法作到的。在Java Web中，你传入的request,response提早过滤掉一些信息，或者提早设置一些参数，而后再传入servlet或者struts的action进行业务逻辑，好比过滤掉非法url（不是login.do的地址请求，若是用户没有登录都过滤掉）,或者在传入servlet或者struts的action前统一设置字符集，或者去除掉一些非法字符（聊天室常常用到的，一些骂人的话）。filter 流程是线性的，url传来以后，检查以后，可保持原来的流程继续向下执行，被下一个filter, servlet接收。

    2.监听器（Listener）：Java的监听器，也是系统级别的监听。监听器随web应用的启动而启动。Java的监听器在c/s模式里面常常用到，它
会对特定的事件产生产生一个处理。监听在不少模式下用到，好比说观察者模式，就是一个使用监听器来实现的，在好比统计网站的在线人数。
又好比struts2能够用监听来启动。Servlet监听器用于监听一些重要事件的发生，监听器对象能够在事情发生前、发生后能够作一些必要的处理。Java里的拦截器提供的是非系统级别发拦截，也就是说，就覆盖面来讲，拦截器不如过滤器强大，可是更有针对性。
    3.拦截器（Interceptor）：java里的拦截器提供的是非系统级别的拦截，Java中的拦截器是基于Java反射机制实现的，更准确的划分，应该是基于JDK实现的动态代理。它依赖于具体的接口，在运行期间动态生成字节码。
拦截器是动态拦截Action调用的对象，它提供了一种机制可使开发者在一个Action执行的先后执行一段代码，也能够在一个Action执行前阻止其
执行，同时也提供了一种能够提取Action中可重用部分代码的方式。在AOP中，拦截器用于在某个方法或者字段被访问以前，进行拦截而后再以前或
者以后加入某些操做。java的拦截器主要是用在插件上，扩展件上好比 Hibernate Spring Struts2等，有点相似面向切片的技术，在用以前先要在
配置文件即xml，文件里声明一段的那个东西。

一、拦截器是基于java的反射机制的，而过滤器是基于函数回调

二、过滤器依赖与servlet容器，而拦截器不依赖与servlet容器
三、拦截器只能对action请求起做用，而过滤器则能够对几乎全部的请求起做用
四、拦截器能够访问action上下文、值栈里的对象，而过滤器不能
五、在action的生命周期中，拦截器能够屡次被调用，而过滤器只能在容器初始化时被调用一次

在action的生命周期中，拦截器能够屡次被调用，而过滤器只能在容器初始化时被调用一次
执行顺序：过滤前 - 拦截前 - Action处理 - 拦截后 - 过滤后。
我的认为过滤是一个横向的过程，首先把客户端提交的内容进行过滤(例如未登陆用户不能访问内部页面的处理)；
过滤经过后，拦截器将检查用户提交数据的验证，作一些前期的数据处理，接着把处理后的数据发给对应的Action；
Action处理完成返回后，拦截器还能够作其余过程，再向上返回到过滤器的后续操做。

4、Spring MVC PK Struts2

咱们用struts2时采用的传统的配置文件的方式，并无使用传说中的0配置。spring3 mvc能够认为已经100%零配置了（除了配置spring mvc-servlet.xml外）。

Spring MVC和Struts2的区别：

1. 机制：spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不一样的。之前认为filter是servlet的一种特殊），这样就致使了两者的机制不一样，这里就牵涉到servlet和filter的区别了。

2. 性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每一个action都会被注入属性，而spring基于方法，粒度更细，但要当心把握像在servlet控制数据同样。spring3 mvc是方法级别的拦截，拦截到方法后根据参数上的注解，把request数据注入进去，在spring3 mvc中，一个方法对应一个request上下文。而struts2框架是类级别的拦截，每次来了请求就建立一个Action，而后调用setter getter方法把request中的数据注入；struts2其实是经过setter getter方法与request打交道的；struts2中，一个Action对象对应一个request上下文。

3. 参数传递：struts是在接受参数的时候，能够用属性来接受参数，这就说明参数是让多个方法共享的。Struts2中自身提供多种参数接受，其实都是经过（ValueStack）进行传递和赋值，而SpringMvc是经过方法的参数进行接收

4. 设计思想上：struts更加符合oop的编程思想， spring就比较谨慎，在servlet上扩展。

5. intercepter的实现机制：struts有以本身的interceptor机制，spring mvc用的是独立的AOP方式。这样致使struts的配置文件量仍是比spring mvc大，虽然struts的配置能继承，因此我以为论使用上来说，spring mvc使用更加简洁，开发效率Spring MVC确实比struts2高。spring mvc是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应，因此说从架构自己上spring3 mvc就容易实现restful url。struts2是类级别的拦截，一个类对应一个request上下文；实现restful url要费劲，由于struts2 action的一个方法能够对应一个url；而其类属性却被全部方法共享，这也就没法用注解或其余方式标识其所属方法了。spring3 mvc的方法之间基本上独立的，独享request response数据，请求数据经过参数获取，处理结果经过ModelMap交回给框架方法之间不共享变量，而struts2搞的就比较乱，虽然方法之间也是独立的，但其全部Action变量是共享的，这不会影响程序运行，却给咱们编码，读程序时带来麻烦。

6. 另外，spring3 mvc的验证也是一个亮点，支持JSR303，处理ajax的请求更是方便，只需一个注解@ResponseBody ，而后直接返回响应文本便可。送上一段代码：

@RequestMapping(value="/whitelists")
public String index(ModelMap map) {
Account account = accountManager.getByDigitId(SecurityContextHolder.get().getDigitId());
List<Group> groupList = groupManager.findAllGroup(account.getId());
map.put("account", account);
map.put("groupList", groupList);
return "/group/group-index";
}

// @ResponseBody ajax响应，处理Ajax请求也很方便
@RequestMapping(value="/whitelist/{whiteListId}/del")
@ResponseBody
public String delete(@PathVariable Integer whiteListId) {
whiteListManager.deleteWhiteList(whiteListId);
return "success";
}

Struts框架

一，Struts2简介：

1，来由：Struts(金属支架)，在程序中表示起支撑做用的通用程序代码，Struts2是在Struts1框架的基础上融合了WebWork优秀框架升级获得的。

2，解释：Struts2框架是一个轻量级的MVC流程框架，轻量级是指程序的代码不是不少，运行时占用的资源不是不少，MVC流程框架就是说它是支持分层开发，控制数据的流程，从哪里来，到那里去，怎么来，怎么去的这样一个框架；

3，升级的改善：

Struts1的缺点：

struts框架基于servlet进行开发的，因此servlet的问题在这个框架中都能体现出来

struts框架的流程是固定的，想要扩展业务流程很是的不方便。

只支持动态视图JSP展示数据，对于如今的SEO（搜索引擎优化）支持很差

Struts2框架改善的地方：

核心基于Filter

流程能够动态扩展

多例建立对象

支持多种视图展示技术（JSP，Freemarker，Volicity）

一个请求在Struts2框架中的处理大概分为如下几个步骤

一、客户端初始化一个指向Servlet容器（例如Tomcat）的请求

二、这个请求通过一系列的过滤器（Filter）（这些过滤器中有一个叫作ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其余框架的集成颇有帮助，例如：SiteMesh Plugin）

三、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否须要调用某个Action

FilterDispatcher是控制器的核心，就是mvc中c控制层的核心。下面粗略的分析下我理解的FilterDispatcher工做流程和原理：FilterDispatcher进行初始化并启用核心doFilter

四、若是ActionMapper决定须要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy

五、ActionProxy经过ConfigurationManager询问框架的配置文件，找到须要调用的Action类 ,这里，咱们通常是从struts.xml配置中读取。

六、ActionProxy建立一个ActionInvocation的实例。

七、ActionInvocation实例使用命名模式来调用，在调用Action的过程先后，涉及到相关拦截器（Intercepter）的调用。

八、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果一般是（但不老是，也多是另外的一个Action链）一个须要被表示的JSP或者FreeMarker的模版。在表示的过程当中可使用Struts2 框架中继承的标签。在这个过程当中须要涉及到ActionMapper

Struts2和struts1的比较

struts2相对于struts1来讲简单了不少，而且功能强大了不少，咱们能够从几个方面来看：

从体系结构来看：struts2大量使用拦截器来出来请求，从而容许与业务逻辑控制器与 servlet-api分离，避免了侵入性；而struts1.x在action中明显的侵入了servlet-api.

从线程安全分析：struts2.x是线程安全的，每个对象产生一个实例，避免了线程安全问题；而struts1.x在action中属于单线程。

性能方面：struts2.x测试能够脱离web容器，而struts1.x依赖servlet-api，测试须要依赖web容器。

请求参数封装对比：struts2.x使用ModelDriven模式，这样咱们直接封装model对象，无须要继承任何struts2的基类，避免了侵入性。

标签的优点：标签库几乎能够彻底替代JSTL的标签库，而且 struts2.x支持强大的ognl表达式。

固然，struts2和struts1相比，在文件上传，数据校验等方面也方便了好多。在这就不详谈了。

1． Struts压缩包内容

文件夹jakarta-struts-1.0.2包含两个目录，lib和webapps。在lib目录中有使用struts建立应用程序是所需的文件：

文件	描述
jdbc2_0-stdext.jar	包含JDBC2.0 Optional Package API类。若是咱们要使用struts提供的数据资源，就须要将这个文件拷贝到WEB-INF/lib下
Struts.jar	包含struts中全部的Java类。一样也须要拷贝到WEB-INF/lib下
*.tld	标记库描述器文件，描述了多个struts标记库中的自定义标记。一样要拷贝到WEB-INF/lib下

在webapps目录下有以下文件：

Web应用程序	描述
Struts-blank.war	一个简单的web应用程序
Struts-documentation.war	包含struts站点上全部struts文档
Struts-example.war	Struts不少特性的示范
Struts-exercisetaglib.war	主要用于对自定义标签库进行增长而使用的测试页，但也能够示范如何使用struts标记
Struts-template.war	包含struts模板标记的介绍和范例
Struts-upload.war	一个简单的例子，示范如何使用struts框架上传文件

框架中所使用的组件：

ActionServlet	控制器
ActionClass	包含事务逻辑
ActionForm	显示模块数据
ActionMapping	帮助控制器将请求映射到操做
ActionForward	用来指示操做转移的对象
ActionError	用来存储和回收错误
Struts标记库	能够减轻开发显示层次的工做

二、Struts 2 验证框架的应用

　　Struts 2 提供了大量的数据校验器，包括表单域校验器和非表单域校验器。

　　（1）必填字符串校验器

　　　该校验器的名字是 requiredstring 其校验规则定义文件以下：

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC

"-//Apache Software Foundation//DTD Struts Configuration 2.1//EN"

"http://struts.apache.org/dtds/struts-2.1.dtd">

<validators>

    <field name = "username">

        <!-- 须要验证的字段的字段名 -->

        <field-validators type = "requiredstring">

            <!-- 去空格 -->

            <param name = "trim">true</param>

            <!-- 错误提示信息 -->

            <message>请输入用户名</message>

        </field-validators>

    </field></validators>

　　文件命名：ActionName-validation.xml:其中ActionName 就是须要校验的用户自定义的Action 类的名字。并且该文件应该与Action 类文件放置在同一路径下。

　　（2）必填校验器

　　该校验器的名字就是 required 。该校验器与requiredstring 的差异就是能够有空字符串。配置以下：

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC

"-//Apache Software Foundation//DTD Struts Configuration 2.1//EN"

"http://struts.apache.org/dtds/struts-2.1.dtd">

<validators>

        <!-- 须要验证的字段的字段名 -->

    <field name = "username">

        <field-validators type = "required">

            <!-- 错误提示信息 -->

            <message>请输入用户名</message>

        </field-validators>

    </field></validators>

　　（3）整数校验器

　　　　该校验器的名字为 int ，该校验器要求字段的整数值必须在必定范围内。配置以下：

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC

"-//Apache Software Foundation//DTD Struts Configuration 2.1//EN"

"http://struts.apache.org/dtds/struts-2.1.dtd">

<validators>

    <!-- 须要验证的字段的字段名 -->

    <field name = "number">

        <field-validators type = "int">

            <!-- 数值的最小值 -->

            <param name = "min">50</param>

            <!-- 数值的最大值 -->

            <param name = "max">100</param>

            <!-- 错误提示信息 -->

            <message>大小必须在50至100之间</message>

        </field-validators>

    </field></validators>

　　(4) 日期校验器

　　该校验器的名字是 date ，该校验器要求字段的日期值必须在指定范围类，因此也有 min 和 max 参数。配置格式：

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC

"-//Apache Software Foundation//DTD Struts Configuration 2.1//EN"

"http://struts.apache.org/dtds/struts-2.1.dtd">

<validators>

    <!-- 须要验证的字段的字段名 -->

    <field name = "date">

        <field-validators type = "date">

            <!-- 时间的最小值 -->

            <param name = "min">1900-01-01</param>

            <!-- 时间的最大值 -->

            <param name = "max">9999-01-01</param>

            <!-- 错误提示信息 -->

            <message>时间必须在1900-01-01至9999-01-01之间</message>

        </field-validators>

    </field></validators>

　　(5) 邮件地址校验器

　　该校验器的名称是 email ，该校验器要求字段的字符若是非空，就必须是合法的邮件地址。格式以下：

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC

"-//Apache Software Foundation//DTD Struts Configuration 2.1//EN"

"http://struts.apache.org/dtds/struts-2.1.dtd">

<validators>

    <!-- 须要验证的字段的字段名 -->

    <field name = "email">

        <field-validators type = "email">

            <!-- 错误提示信息 -->

            <message>邮箱地址无效</message>

        </field-validators>

    </field></validators>

　　(6) 网址校验器

　　该校验器的名称是 url , 该校验器要求字段的字符若是非空，就必须是合法的URL地址。格式和 (5)邮箱校验器相似。

　　(7) 字符穿长度校验器

　　该校验器的名称是 stringlength ，该校验器要求字段的字符长度必须在指定的范围之间，因此它有 minLength 和 maxLength 两个参数。

它的个数如（3）整数校验器相似。

　　(8) 正则表达式校验器

　　该校验器的名称是 regex ，它检查被校验字段是否匹配一个正则表达式。

三、Struts 2 拦截器：

　　Struts 2 框架的绝大部分功能是经过拦截器来完成的，当FilterDispatcher拦截到用户请求后，大量拦截器将会对用户请求进行处理，而后调用用户

自定义的Action 类中的方法来处理请求。

　　拦截器的配置:

　　在struts.xml文件中来定义的，使用<interceptor.../>元素，格式以下：

　　</interceptor>

　　其中<param.../>能够省略，但在有的时候就须要为其传入拦截器参数。

　　有时候一个Action要配置不仅一个拦截器，每每多个拦截器一块儿使用来进行过滤。这时候就要配置几个拦截器组成的拦截器栈。定义拦截器栈用

<interceptor-stack.../>，格式以下：

　　<interceptor-stack name = "拦截器栈名">

　　　　<interceptor-ref name = "拦截器一"></interceptor-ref>

　　　　<interceptor-ref name = "拦截器二"></interceptor-ref>

　　　　<interceptor-ref name = "拦截器三"></interceptor-ref>

　　</interceptor-stack>

　　注意：在配置拦截器栈时，用到的拦截器必须是已经存在的拦截器。拦截器栈也能够引用拦截器栈。

　　拦截器实现类：

　　Struts 2 提供了一些接口或类供程序员自定义拦截器。如：com.opensymphony.xwork2.interceptor.Interceptor 接口。

该接口中有三个方法：

　　void init () ：用于初始化资源。

　　String intercept (ActionInvocation invocation) ：用于实现拦截的动做。

　　destroy () ：用于销毁在init()方法中打开的资源。

Spring MVC

模型-视图-控制器（MVC）是一个众所周知的以设计界面应用程序为基础的设计模式。它主要经过分离模型、视图及控制器在应用程序中的角色将业务逻辑从界面中解耦。一般，模型负责封装应用程序数据在视图层展现。视图仅仅只是展现这些数据，不包含任何业务逻辑。控制器负责接收来自用户的请求，并调用后台服务（manager或者dao）来处理业务逻辑。处理后，后台业务层可能会返回了一些数据在视图层展现。控制器收集这些数据及准备模型在视图层展现。MVC模式的核心思想是将业务逻辑从界面中分离出来，容许它们单独改变而不会相互影响。

DispatcherServlet是前置控制器，配置在web.xml文件中

<load-on-startup>1</load-on-startup>是启动顺序，让这个Servlet随Servletp容器一块儿启动。

HandlerMapping接口 -- 处理请求的映射

HandlerMapping接口的实现类：

SimpleUrlHandlerMapping 经过配置文件，把一个URL映射到Controller

DefaultAnnotationHandlerMapping 经过注解，把一个URL映射到Controller类上

<context:annotation-config />

<context:component-scan base-package="controller"></context:component-scan>

@Controller //相似Struts的Action

@RequestMapping("test/login.do") // 请求url地址映射，相似Struts的action-mapping

// @RequestParam是指请求url地址映射中必须含有的参数(除非属性required=false)

// @RequestParam可简写为：@RequestParam("username")

@Resource(name = "loginService") // 获取applicationContext.xml中bean的id为loginService的，并注入

private LoginService loginService; //等价于spring传统注入方式写get和set方法，这样的好处是简洁工整，省去了没必要要得代码

@Controller 声明Action组件
@Service    声明Service组件    @Service("myMovieLister")
@Repository 声明Dao组件
@Component   泛指组件, 当很差归类时.
@RequestMapping("/menu") 请求映射
@Resource 用于注入，( j2ee提供的 ) 默认按名称装配，@Resource(name="beanName")
@Autowired 用于注入，(srping提供的) 默认按类型装配
@Transactional( rollbackFor={Exception.class}) 事务管理
@ResponseBody   用于ajax return用于返回数据
@Scope("prototype")   设定bean的做用域

转发与重定向

能够经过redirect/forward:url方式转到另外一个Action进行连续的处理。

能够经过redirect:url 防止表单重复提交。

写法以下：

return "forward:/order/add";

return "redirect:/index.jsp";

Xml代码

<context:component-scan base-package="com.app,com.core,JUnit4" ></context:component-scan>

<mvc:annotation-driven />

</bean>

<mvc:interceptors>

</mvc:interceptors>

<mvc:default-servlet-handler/>

<mvc:resources mapping="/images/**" location="/images/" cache-period="31556926"/>

<mvc:resources mapping="/js/**" location="/js/" cache-period="31556926"/>

<mvc:resources mapping="/css/**" location="/css/" cache-period="31556926"/>

实现全局的异常处理？

在spring MVC的配置文件中：

Xml代码

<value>/error/error</value>

</property>

</property>

<value>org.springframework.web.servlet.handler.SimpleMappingExceptionResolver</value>

</property>

</bean>

5、spring

1，什么是spring框架

spring是J2EE应用程序框架，是轻量级的IoC和AOP的容器框架，主要是针对javaBean的生命周期进行管理的轻量级容器，能够单独使用，也能够和Struts框架，ibatis框架等组合使用。

2，架构概述

1）IoC(Inversion of Control)控制反转，对象建立责任的反转，在spring中BeanFacotory是IoC容器的核心接口，负责实例化，定位，配置应用程序中的对象及创建这些对象间的依赖。XmlBeanFacotory实现BeanFactory接口，经过获取xml配置文件数据，组成应用对象及对象间的依赖关系。

spring中有三种注入方式，一种是set注入，一种是接口注入，另外一种是构造方法注入。

2）AOP面向切面编程

aop就是纵向的编程，以下图所示，业务1和业务2都须要一个共同的操做，与其往每一个业务中都添加一样的代码，不如写一遍代码，让两个业务共同使用这段代码。

spring中面向切面变成的实现有两种方式，一种是动态代理，一种是CGLIB，动态代理必需要提供接口，而CGLIB实现是有继承。

3，为何使用spring框架

在不使用spring框架以前，咱们的service层中要使用dao层的对象，不得不在service层中new一个对象。以下：

[java] view plain copy print ?

//dao层对象

public class UserDao{

publicvoid insert(User user){}

}

//service层对象

public classUserService{

publicvoid insert(User user){

UserDaouserdao = new UserDao();

userdao.insert(user);

}

存在的问题：层与层之间的依赖。

使用框架后：

[java] view plain copy print ?

//dao层对象

public class UserDao{

publicvoid insert(User user){}

}

//service层对象

public classUserService{

privateUserDao userdao;

publicUserDao getUserdao() {

returnuserdao;

}

publicvoid setUserdao(UserDao userdao) {

this.userdao= userdao;

}

publicvoid insert(User user){

userdao.insert(user);

}

service层要用dao层对象须要配置到xml配置文件中，至于对象是怎么建立的，关系是怎么组合的都交给了spring框架去实现。

4，框架优势

轻量级的容器框架没有侵入性

使用IoC容器更加容易组合对象直接间关系，面向接口编程，下降耦合

Aop能够更加容易的进行功能扩展，遵循ocp开发原则

建立对象默认是单例的，不须要再使用单例模式进行处理

5，缺点：业务功能依赖spring特有的功能，依赖与spring环境。

Spring七大亮点：

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

BeanFactory和ApplicationContext是了解Spring核心的关键。

org.springframework.beans和org.springframework.context这两个包是Spring最基本、最重要的包，为了实现一种无侵入式的框架，代码中大量引用java中的反射机制，经过动态调用的方式避免了硬编码，为Spring的反向控制特性提供了基础。在这两个包中，最重要的类是BeanFactory：提供一种先进的配置机制来管理任何种类的Bean。ApplicationContext：创建在BeanFactory的基础上，并增长了其余的功能。例如对于国际化的支持、获取资源、事件传递等

Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

获取Spring的上下文环境

1 WebApplicationContextUtils工具类，在web项目中使用；缺点依赖于Servlet容器；

2 ClassPathXmlApplicationContext工具类，这种实际只适合测试时候使用，须要读配置文件；

三、在文件中配置

Spring AOP：AOP（Aspect Oriented Programming），即面向切面编程，能够说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来创建一种对象层次结构，用于模拟公共行为的一个集合。不过OOP容许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码每每横向地散布在全部对象层次中，而与它对应的对象的核心功能毫无关系对于其余类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它致使了大量代码的重复，而不利于各个模块的重用。

AOP技术偏偏相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减小系统的重复代码，下降模块之间的耦合度，并有利于将来的可操做性和可维护性。

使用"横切"技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特色是，他们常常发生在核心关注点的多处，而各处基本类似，好比权限认证、日志、事物。AOP的做用在于分离系统中的各类关注点，将核心关注点和横切关注点分离开来。

AOP核心概念

一、横切关注点

对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点

二、切面（aspect）

类是对物体特征的抽象，切面就是对横切关注点的抽象

三、链接点（joinpoint）

被拦截到的点，由于Spring只支持方法类型的链接点，因此在Spring中链接点指的就是被拦截到的方法，实际上链接点还能够是字段或者构造器

四、切入点（pointcut）

对链接点进行拦截的定义

五、通知（advice）

所谓通知指的就是指拦截到链接点以后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类

六、目标对象

代理的目标对象

七、织入（weave）

将切面应用到目标对象并致使代理对象建立的过程

八、引入（introduction）

在不修改代码的前提下，引入能够在运行期为类动态地添加一些方法或字段

Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不一样数据库供应商抛出的错误消息。异常层次结构简化了错误处理，而且极大地下降了须要编写的异常代码数量（例如打开和关闭链接）。Spring DAO 的面向 JDBC 的异常听从通用的 DAO 异常层次结构。

1)优化了的异常类型体系:
      细化了数据访问异常，丰富了异常类型
      (都是 Unchecked Exception，这种异常不会变更，采用同一种异常，表示同一种现象，与使用的持久化技术无关)
2)使用模板回调模式，开发者再也不写模式化代码，简化编程：
      不变：资源的获取，资源的释放，异常转化（Spring提供了模板类对此负责）
      变化：SQL，变量，结果集的提取

基于JDBC的DAO实现
基于 Hibernate 的DAO实现

DataSource接口：

Spring使用DataSource对象来完成获取数据库链接。

使用Spring JDBC时，既能够从JNDI获取数据源，也能够自行配置数据源。

DBCP：DBCP是apache一个数据库链接池项目，使用DBCP须要有三个包：COMMON-DBCP.JAR,COMMON-POOL.JAR和COMMON-COLLECTIONS.JAR

配置：

C3P0是一个开源的JDBC链接池，它实现了数据源和JNDI绑定。配置：

C3P0与DBCP的区别：dbcp没有自动的去回收空闲链接的功能，C3P0有

Spring ORM(对象关系映射)：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。全部这些都听从 Spring 的通用事务和 DAO 异常层次结构。

为何须要ORM (Hibernate\Entity EJB\ IBATIS\TopLink)
表明了目前程序设计语言的主流和趋势，其具有很是多的优点，好比：
      面向对象的建模、操做。
      多态、继承。
      摒弃难以理解的过程。
      简单易用，易理解性。
但数据库的发展并未与程序设计语言同步，并且，关系数据库系统的某些优点，也是面向对象的语言目前没法解决的。好比：
      大量数据操做查找、排序。
      集合数据链接操做、映射。
      数据库访问的并发、事务。
      数据库的约束、隔离。
面对这种面向对象语言与关系数据库系统并存的局面，采用ORM就变成一种必然。

Spring Web 模块：Web 上下文模块创建在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。因此，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工做。

Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。经过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

spring的启动过程：

一、首先，对于一个web应用，其部署在web容器中，web容器提供其一个全局的上下文环境，这个上下文就是ServletContext，其为后面的spring IoC容器提供宿主环境；

二、其次，在web.xml中会提供有contextLoaderListener。在web容器启动时，会触发容器初始化事件，此时contextLoaderListener会监听到这个事件，其contextInitialized方法会被调用，在这个方法中，spring会初始化一个启动上下文，这个上下文被称为根上下文，即WebApplicationContext，这是一个接口类，确切的说，其实际的实现类是XmlWebApplicationContext。这个就是spring的IoC容器，其对应的Bean定义的配置由web.xml中的context-param标签指定。在这个IoC容器初始化完毕后，spring以WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE为属性Key，将其存储到ServletContext中，便于获取；

三、再次，contextLoaderListener监听器初始化完毕后，开始初始化web.xml中配置的Servlet，这个servlet能够配置多个，以最多见的DispatcherServlet为例，这个servlet其实是一个标准的前端控制器，用以转发、匹配、处理每一个servlet请求。DispatcherServlet上下文在初始化的时候会创建本身的IoC上下文，用以持有spring mvc相关的bean。在创建DispatcherServlet本身的IoC上下文时，会利用WebApplicationContext.ROOTWEBAPPLICATIONCONTEXTATTRIBUTE先从ServletContext中获取以前的根上下文(即WebApplicationContext)做为本身上下文的parent上下文。有了这个parent上下文以后，再初始化本身持有的上下文。这个DispatcherServlet初始化本身上下文的工做在其initStrategies方法中能够看到，大概的工做就是初始化处理器映射、视图解析等。这个servlet本身持有的上下文默认实现类也是mlWebApplicationContext。初始化完毕后，spring以与servlet的名字相关(此处不是简单的以servlet名为Key，而是经过一些转换，具体可自行查看源码)的属性为属性Key，也将其存到ServletContext中，以便后续使用。这样每一个servlet就持有本身的上下文，即拥有本身独立的bean空间，同时各个servlet共享相同的bean，即根上下文(第2步中初始化的上下文)定义的那些bean。

6、Hibernate框架简述

Hibernate的核心组件
在基于MVC设计模式的JAVA WEB应用中，Hibernate能够做为模型层/数据访问层。它经过配置文件(hibernate.properties或hibernate.cfg.xml)和映射文件(***.hbm.xml)把JAVA对象或PO(Persistent Object,持久化对象)映射到数据库中的数据库，而后经过操做PO，对数据表中的数据进行增，删，改，查等操做。

除配置文件，映射文件和持久化类外，Hibernate的核心组件包括如下几部分：

Configuration类：用来读取Hibernate配置文件，并生成SessionFactory对象。
b)SessionFactory接口：产生Session实例工厂。
c)Session接口：用来操做PO。它有get(),load(),save(),update()和delete()等方法用来对PO进行加载，保存，更新及删除等操做。它是Hibernate的核心接口。
d)Query接口：用来对PO进行查询操。它能够从Session的createQuery()方法生成。
e)Transaction接口：用来管理Hibernate事务，它主要方法有commit()和rollback()，能够从Session的beginTrancation()方法生成。

Hibernate的运行过程
Hibernate的运行过程以下：
A:应用程序先调用Configration类，该类读取Hibernate的配置文件及映射文件中的信息，并用这些信息生成一个SessionFactpry对象。
B:而后从SessionFactory对象生成一个Session对象，并用Session对象生成Transaction对象;可经过Session对象的get(),load(),save(),update(),delete()和saveOrUpdate()等方法对PO进行加载，保存，更新，删除等操做;在查询的状况下，可经过Session对象生成一个Query对象，而后利用Query对象执行查询操做;若是没有异常，Transaction对象将提交这些操做结果到数据库中。

Hibernate的运行过程以下图：

7、PL/SQL

PL/SQL也是一种程序语言，叫作过程化SQL语言(Procedural Language/SQL)。PL/SQL是Oracle数据库对SQL语句的扩展。在普通SQL语句的使用上增长了编程语言的特色，因此PL/SQL就是把数据操做和查询语句组织在PL/SQL代码的过程性单元中，经过逻辑判断、循环等操做实现复杂的功能或者计算的程序语言

1 PL/SQL的做用

使用PL/SQL能够编写具备不少高级功能的程序，虽然经过多个SQL语句可能也能实现一样的功能，可是相比而言，PL/SQL具备更为明显的一些优势：

⒈可以使一组SQL语句的功能更具模块化程序特色；

⒉采用了过程性语言控制程序的结构；

⒊能够对程序中的错误进行自动处理，使程序可以在遇到错误的时候不会被中断；

⒋具备较好的可移植性，能够移植到另外一个 Oracle数据库中；

⒌集成在数据库中，调用更快；

⒍减小了网络的交互，有助于提升程序性能。

2 PL/SQL程序的基本结构

PL/SQL块由四个基本部分组成：声明、执行体开始、异常处理、执行体结束。

下面是四个部分的基本结构：

DECLARE —— 可选部分

变量、常量、游标、用户定义异常的声明

……

BEGIN —— 必要部分

SQL语句和PL/SQL语句构成的执行程序

……

EXCEPTION —— 可选部分

程序出现异常时，捕捉异常并处理异常

……

END；—— 必须部分

Java项目通常发布在什么环境?

通常都采用linux，相对windows而言，有几个优点：
1：免费
2：更安全
3：选择ubuntu server版，更省资源，系统更快
4：成本低，不过对开法者要求更高一些。

Java项目打包发布

若是只想发布为一个可执行的jar包,使用eclipse的Export功能就能够了使用eclipse的Export功能,将项目中的全部package打包为一个pet.jar文件,假定项目中全部配置文件都在项目根目录的config文件夹.

新建一个文件夹bushu,将项目中的config文件夹放进来用winrar打开项目引用的全部jar文件,将文件中的全部包文件夹添加进pet.jar文件建立pet.dat文件,内容:start java -Xmx512m -jar pet.jar 运行pet.dat 若是最终想发布为可执行程序我使用开源项目jsmooth提供的软件项目地址使用eclipse的Export功能,将项目中的全部package打包为一个pet.jar文件,个人项目中全部配置文件都在项目根目录的config文件夹. 新建一个文件夹bushu,将项目中的config文件夹、引用的外部jar包和pet.jar文件都放进来,全部包文件都放到bushu下的lib目录下打开jsmooth,新建一个项目,设置好后编译就能够生成exe文件,附件中我截取了全部jsmooth配置的图片. 首先，将编译好的程序打包成jar文件，而后作出exe，这样代码就不可见了；可是exe文件在没有安装jre的电脑上不能运行，若是要求客户再去安装jre 设置环境变量就不雅了。咱们须要将jre打包。这几步操做网上介绍的插件和方法不少，但有的好用有的很差用，并且有的还须要注册。通过尝试比较，在“千里冰封”的博客上获得了很大的帮助。整理一下。使用这几个工具，您也能够顺利的发布您的java程序！ 1 打包成双击可执行的jar文件。推荐插件：fatJar（Eclipse使用）下载地址 http://sourceforge.net/project/showfiles.php?group_id=115990&package_id=125924 我用的是Eclipse，它自带的打包方法在打包一些图片等资源时不是很爽。可使用这个插件。

九、Mybatis

　　MyBatis是一个支持普通SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis消除了几乎全部的JDBC代码和参数的手工设置以及对结果集的检索封装。MyBatis可使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。

添加相应的jar包

　　【mybatis】

　　mybatis-3.1.1.jar

【MYSQL驱动包】
　　　　mysql-connector-java-5.1.7-bin.jar

若是使用 Maven 来构建项目，则需将下面的 dependency 代码置于 pom.xml 文件中：

<groupId>org.mybatis</groupId>

<artifactId>mybatis</artifactId>

</dependency>

1、添加Mybatis的配置文件conf.xml

　　在src目录下建立一个conf.xml文件，以下图所示：

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

2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

3 <configuration>

4 <environments default="development">

5 <environment id="development">

6 <transactionManager type="JDBC" />

7

8 <dataSource type="POOLED">

9 <property name="driver" value="com.mysql.jdbc.Driver" />

10 <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />

11 <property name="username" value="root" />

12 <property name="password" value="XDP" />

13 </dataSource>

14 </environment>

15 </environments>

17 </configuration>

User类的代码以下：

复制代码

1 package me.gacl.domain;

3 /**

4 * @author gacl

5 * users表所对应的实体类

6 */

7 public class User {

9 //实体类的属性和表的字段名称一一对应

10 private int id;

11 private String name;

12 private int age;

14 public int getId() {

15 return id;

16 }

18 public void setId(int id) {

19 this.id = id;

20 }

22 public String getName() {

23 return name;

24 }

26 public void setName(String name) {

27 this.name = name;

28 }

30 public int getAge() {

31 return age;

32 }

34 public void setAge(int age) {

35 this.age = age;

36 }

38 @Override

39 public String toString() {

40 return "User [id=" + id + ", name=" + name + ", age=" + age + "]";

41 }

42 }

定义操做users表的sql映射文件userMapper.xml

建立一个me.gacl.mapping包，专门用于存放sql映射文件，在包中建立一个userMapper.xml文件，

　userMapper.xml文件的内容以下：

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

2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

3 <!-- 为这个mapper指定一个惟一的namespace，namespace的值习惯上设置成包名+sql映射文件名，这样就可以保证namespace的值是惟一的

4 例如namespace="me.gacl.mapping.userMapper"就是me.gacl.mapping(包名)+userMapper(userMapper.xml文件去除后缀)

5 -->

6 <mapper namespace="me.gacl.mapping.userMapper">

7 <!-- 在select标签中编写查询的SQL语句，设置select标签的id属性为getUser，id属性值必须是惟一的，不可以重复

8 使用parameterType属性指明查询时使用的参数类型，resultType属性指明查询返回的结果集类型

9 resultType="me.gacl.domain.User"就表示将查询结果封装成一个User类的对象返回

10 User类就是users表所对应的实体类

11 -->

12 <!--

13 根据id查询获得一个user对象

14 -->

15 <select id="getUser" parameterType="int"

16 resultType="me.gacl.domain.User">

17 select * from users where id=#{id}

18 </select>

19 </mapper>

　四、在conf.xml文件中注册userMapper.xml文件

复制代码

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

2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

3 <configuration>

4 <environments default="development">

5 <environment id="development">

6 <transactionManager type="JDBC" />

7

8 <dataSource type="POOLED">

9 <property name="driver" value="com.mysql.jdbc.Driver" />

10 <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />

11 <property name="username" value="root" />

12 <property name="password" value="XDP" />

13 </dataSource>

14 </environment>

15 </environments>

17 <mappers>

18 <!-- 注册userMapper.xml文件，

19 userMapper.xml位于me.gacl.mapping这个包下，因此resource写成me/gacl/mapping/userMapper.xml-->

20 <mapper resource="me/gacl/mapping/userMapper.xml"/>

21 </mappers>

23 </configuration>

　　五、编写测试代码：执行定义的select语句

　　建立一个Test1类，编写以下的测试代码：

package me.gacl.test;

import java.io.IOException;

import java.io.InputStream;

import java.io.Reader;

import me.gacl.domain.User;

import org.apache.ibatis.io.Resources;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class Test1 {

public static void main(String[] args) throws IOException {

//mybatis的配置文件

String resource = "conf.xml";

//使用类加载器加载mybatis的配置文件（它也加载关联的映射文件）

InputStream is = Test1.class.getClassLoader().getResourceAsStream(resource);

//构建sqlSession的工厂

SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);

//使用MyBatis提供的Resources类加载mybatis的配置文件（它也加载关联的映射文件）

//Reader reader = Resources.getResourceAsReader(resource);

//构建sqlSession的工厂

//SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);

//建立能执行映射文件中sql的sqlSession

SqlSession session = sessionFactory.openSession();

/**

* 映射sql的标识字符串，

* me.gacl.mapping.userMapper是userMapper.xml文件中mapper标签的namespace属性的值，

* getUser是select标签的id属性值，经过select标签的id属性值就能够找到要执行的SQL

String statement = "me.gacl.mapping.userMapper.getUser";//映射sql的标识字符串

//执行查询返回一个惟一user对象的sql

User user = session.selectOne(statement, 1);

System.out.println(user);

}

十、Svn使用教程

http://www.cnblogs.com/armyfai/p/3985660.html

创建用户组,在VisualSVN Server Manager窗口的左侧右键单击用户组,选择Create Group或者新建->Group,

注意事项：

.svn这个隐藏目录记录着两项关键信息：工做文件的基准版本和一个本地副本最后更新的时间戳，千万不要手动修改或者删除这个.svn隐藏目录和里面的文件!!,不然将会致使你本地的工做拷贝(静态试图)被破坏，没法再进行操做。

1) TortoiseSVN图标介绍

一个新检出的工做复本使用绿色的对勾重载，表示Subversion状态正常。

在你开始编辑一个文件以后，状态就变成了已修改，而图标重载已变成了红色感叹号。经过这种方式，你能够很容易地看出那些文件从你上次更新工做复本被修改过，且须要提交。

若是在提交的过程当中出现了冲突，图标就会变成了黄色感叹号。

加号告诉你有一个文件或者目录已经被计划加入到版本控制中。

2. 增长(Add)

在test项目文件下，新建一个b.txt文件，提交到版本库的方法以下2种：

1. 先提到变动列表中，再commit到配置库中，选择新增文件，右键SVN菜单执行“Add“操做提交到”变动列表中”，而后右键SVN菜单执行”SVN Commit”提交到版本库中。

2. 不提交到变动列表中，而是直接commit配置库中，选择该文件，右键svn菜单执行”SVN Commit”操做。

3. 删除(Delete)

若是被删除的文件还未入版本库，则能够直接使用操做系统的删除操做删除该文件。

若是被删除的文件已入版本库，则删除的方法以下：

选择被删除文件，右键svn菜单执行”delete”操做，而后选择被删除文件的父目录，右键svn菜单执行”SVN Commit”.

使用操做系统的删除操做删除该文件，而后选择被删除文件的父目录，右键svn菜单执行”SVN Commit”,在变动列表中选择被删除的文件

4. 更名(Rename)

修改文件名，选中须要重命名的文件或文件夹，而后右键“TortoiseSVNàRename“，在弹出的对话框中输入新名称，点击”ok”按钮，并将修改文件名后的文件或文件夹经过 “SVN Commit”提交到SVN服务器上。

5. SVN还原(SVN Revert)

右击想要回退的文件或者文件夹，在TortoiseSVN弹出菜单中选择”Update to reversion…”

6. 检查更新(Check for modifications)

此功能能够显示你所作的修改有哪些尚未提交的，此功能不光能看到对文件的修改变化，全部的变化都能看到，包括增长文件或者目录，删除文件或者目录，移动文件或者目录等，若是你点击了检查版本库，那你还能够看到版本库里的改动，既别人提交了哪些文件的改动，你还没更新到本地，以下：

7. SVN更新(SVN Update)

更新本地代码与SVN服务器上最新的版本一致，只要在须要更新的文件夹上点击右键或者在文件下空白处点击右键，选择”SVN Update” (获取指定版本中的内容，点击右键执行SVN菜单中的“Update to reversion“)，就能够了。

7.1 如何解决冲突文件

对于每一个冲突的文件Subversion在你的目录下放置了三个文件：以下：

为何会产生冲突代码呢？缘由很简单就是由于不一样的人，同时修改了同一个文件的同一个地方，这时候，他提交了，我没有提交，我就提交不了，这个时候咱们要进行先更新，而后在进行提交便可，那若是产生冲突，会生成如上3个文件。

解决方案以下：

首先咱们能够看下1.txt代码以下：

<<<<<<< .mine

aaaasdf11222333 dderderder

=======

b>>>>>>> .r5

而后我去掉多余的代码，1.txt变成这样

aaaasdf11222333 dderderder

进行提交，仍是提交不了，以下所示：

为何？由于冲突会产生上面的三个文件，有上面3个文件存在确定提交不了，这三个文件代码及解释以下：

1.txt.mine 是冲突前本身的文件。能够看下内容以下：

aaaasdf11222333 dderderder

2. 1.txt.r4 是冲突前本地的版本文件

内容以下：aaaasdf11222333

3. 1.txt.r5 是别人赶在你以前提交的版本

内容以下： b

其中,<<<<<<<<.mine .....=======之间的代码是你本身的，而======......>>>>>>>.r5是别人与你冲突的代码部分

这样就不难理解为何会产生冲突这种奇怪的东西了，由于大家修改的同一块代码，固然会产生冲突。

解决方案以下：

假如我如今的1.txt中的冲突内容以下：

<<<<<<< .mine

6666666666666600000

=======

66666666666aaaaaaaaaa666

>>>>>>> .r16
前面说过 <<<<<<< .mine …… =======

……之间的代码是我未产生冲突以前修改的代码，

======= ………>>>>>>> .r16 这中间……的代码是别人与我冲突代码的部分，从上面的代码能够看到 aaaaaaaaa是我同事新增的 ,00000是我后增长的。

使用revert(回滚)操做，该操做表示用户放弃本身的更新代码，而后直接提交，这个时候你的代码就会使服务器上最新的代码，即A用户提交的新代码，你的代码不会被提交，以下所示：

点击ok按钮后能够看到其余三个文件都自动删掉了，1.txt代码变成以下代码：

66666666666aaaaaaaaaa666

也就是a用户提交的代码，我本身更新的代码须要本身动手复制进去便可提交commit。

假如我如今3.txt产生冲突代码以下：

<<<<<<< .mine

333333338888888888888=======

3333cccccccccc3333>>>>>>> .r16

经过第一点咱们知道，333333338888888888888这个内容是我修改后，未产生冲突以前的内容，3333cccccccccc3333这个代码是A用户提交的代码，从上面得知 A用户新增内容是ccccccc，而我新增的内容是8888888。

那么第二种解决方法以下：

选择文件->右键Editconficts：这种方法须要冲突双方通过协商以后将代码更改统一以后再提交。不只解决了冲突并且还保证了代码是正确的，由于只有一方的代码被提交.

如上图所示，红色的部分是冲突代码：theirs表示当前服务器端最新的代码，Mine表示本身修改后的代码，Merged表示合并后的代码。点击红色后右键选择：use this text block就能够将该部分代码做为合并后的代码

接下来再说说因为冲突致使重要代码被覆盖的状况。冲突发生时若是采起的措施不对可能会致使部分代码丢失，若是想要还原以前的代码也很容易。

选择文件->右键选择show log在这里面你能够看见以前提交的全部版本，找到你想要恢复的版本右键选择revert to this version 就能够恢复了.

SVN提交(SVN Commit)

Svn的提交是将在工做空间作的修改进行提交，包括文件内容的修改，文件或目录的添加，删除，命名，移动等操做。以下图所示:

8. 显示日志(Show log)

经过此功能能够查到谁，何时，对那个目录下的那些文件进行了那些操做，以下图：

9. 版本库浏览(Repo-browser)

此功能是用来浏览须要查看的资料库，在本地文件夹下点击右键，选择TortoiseSVNàRepo-browser,在弹出的对话框中输入资料库地址，再输入用户名和密码，就能查看到你须要查看到版本库的内容，在这你还能看到那些文件被谁锁定了，以下图：

三：建立分支合并相互操做

项目中为什么要建立分支，及合并？

好比我如今项目全部的文件放在主干上(trunk)中，因为需求的变动，须要增长新的需求，可是咱们主干上还要继续往下开发，在此咱们能够新建一个分支，来作增长新的需求那一块，主干上继续开发，等分支上代码没有问题的时候，再合并到主干上来。

建立分支的最大的目的就是跟主线进行并行开发时候不影响主线的开发。

如何操做？

假如我本地新建一个文件夹test下有2个文件夹trunk(存放主干上的代码)和branch(存放分支上的代码)，以下所示：

一：先提取主干上的代码。

点击trunk --> 鼠标右键 --> 点击SVN Checkout --> 弹出一个对话框，以下图所示：

其中上面的URL是从服务器VisualSVN Server上获取的，以下所示：

直接右键qianduan3 --> Copy URL to Clipboard 便可。

其中qianduan3项目有以下文件，以下图所示：

最后点击上面的checkout按钮后，就能够在主干上把代码从远程服务器上获取到，以下所示：

二：新建分支

从trunk（主干上）建立分支(branch)步骤以下：

1. 右键trunk --> branch/Tag 以下图：

在弹出的对话框以下图：

点击ok按钮后，就能够在VisualSVN Serval服务器上新增newBranch，是从如上服务器qianduan3上的文件拷贝一份的，以下所示：

如今咱们能够再来看看本地branch文件夹了，我如今直接进入branch文件下，右键 --> Chenckout下，就能够把newBranch下的全部文件提取出来了，以下所示：

点击ok按钮就能够把文件提取出来了，以下图所示：

分支目前创建在svn的服务器端，本地并无更新，对本地branch文件夹右键--> update便可，就能够更新到分支代码，以下所示：

四：合并分支到主干上

好比我如今对branch分支上新增3.txt文件，而后提交上去，以下所示：

我如今想把分支上的代码3.txt合并到主干上trunk，如今要怎么合并呢？步骤以下：

1. 回到咱们刚刚的主干（trunk）文件夹下，鼠标右键该文件夹 --> TortoiseSVN --> Merge 以下图所示：

在弹出的窗口，以下图所示：

接着点击【Next】下一步，以下图所示：

再接着【Next】下一步，以下图所示：

就能够看到主干trunk上多加了一个3.txt，就是从分支上合并过来的。

五：合并主干到分支。

若是主干上有一些更新，好比说jar包更新等等，那么这些要更新到分支上去，如何操做呢？好比我如今在主干上新建一个4.txt文件，好比以下：

我如今的分支上目录以下：

如今是想把主干上的4.txt合并到分支上来，要如何操做？

步骤以下，仍是和刚刚操做相似.

1. 咱们在分支点击branch --> 右键TortoiseSVN --> Merge 以下图所示：

在弹出新窗口后，以下图所示：

接着点击【Next】下一步，以下图所示：

继续下一步，以下图：

最后直接merge，就能够看到分支branch上也有主干上的4.txt文件了，也就是说，合并主干到分支上也是能够的，以下图所示：

十一、项目流程

理论上应该是：

1、立项

一、项目的功能的范围、实现技术方法和细节

二、须要多少人，须要的开发周期（根据客户的需求）

三、分析成本和风险

四、有相应的利润，能够立项

2、需求调研；

3、需求评审、肯定；

4、概要设计（对技术框架、模块、功能的肯定）；

5、详要设计（对表、业务联系的肯定）；

6、架构师总体架构软件、布置开发任务；

7、整合软件；

8、测试；

9、试运行、维护；

10、正式运行

在实际中跟过二个项目，都是具体和用户交涉，和理论仍是有出入的。

------解决方案--------------------