框架概述

什么是框架

什么是框架

框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法;另一种 定义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。 简而言之，框架其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别 人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。

框架要解决的问题

框架要解决的最重要的一个问题是技术整合的问题，在 J2EE 的 框架中，有着各种各样的技术，不同的 软件企业需要从 J2EE 中选择不同的技术，这就使得软件企业最终的应用依赖于这些技术，技术自身的复杂性和技 术的风险性将会直接对应用造成冲击。而应用是软件企业的核心，是竞争力的关键所在，因此应该将应用自身的设计和具体的实现技术解耦。这样，软件企业的研发将集中在应用的设计上，而不是具体的技术实现，技术实现是应 用的底层支撑，它不应该直接对应用产生影响。

框架一般处在低层应用平台（如 J2EE）和高层业务逻辑之间的中间层。

软件开发的分层重要性

框架的重要性在于它实现了部分功能，并且能够很好的将低层应用平台和高层业务逻辑进行了缓和。为了实现
软件工程中的“高内聚、低耦合”。把问题划分开来各个解决，易于控制，易于延展，易于分配资源。我们常见的 MVC 软件设计思想就是很好的分层思想。

分层开发下的常见框架

常见的 JavaEE 开发框架：
1、解决数据的持久化问题的框架：Mybatis:
作为持久层的框架，还有一个封装程度更高的框架就是Hibernate，但这个框架因为各种原因目前在国内的 流行程度下降太多，现在公司开发也越来越少使用。目前使用 Spring Data 来实现数据持久化也是一种趋势。
2、解决 WEB 层问题的 MVC 框架:SpringMVC
3、解决技术整合问题的框架：Spring

MyBatis 框架概述

mybatis是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql语句本身， 而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。 mybatis通过xml 或注解的方式将要执行的各种statement配置起来，并通过java对象和statement 中 sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并 返回。 采用 ORM 思想解决了实体和数据库映射的问题，对 jdbc进行了封装，屏蔽了 jdbc api 底层访问细节，使我 们不用与 jdbc api 打交道，就可以完成对数据库的持久化操作。 为了我们能够更好掌握框架运行的内部过程，并且有更好的体验，下面我们将从自定义 Mybatis 框架开始来 学习框架。此时我们将会体验框架从无到有的过程体验，也能够很好的综合前面阶段所学的基础。

jdbc 问题分析

1、数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。
2、Sql 语句在代码中硬编码，造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java 代码。
3、使用 preparedStatement 向占有位符号传参数存在硬编码，因为 sql 语句的 where 条件不一定，可能 多也可能少，修改 sql 还要修改代码，系统不易维护。
4、对结果集解析存在硬编码（查询列名），sql 变化导致解析代码变化，系统不易维护，如果能将数据库记 录封装成 pojo对象解析比较方便。

day01

1、什么是框架？
它是我们软件开发中的一套解决方案，不同的框架解决的是不同的问题。
使用框架的好处：
框架封装了很多的细节，使开发者可以使用极简的方式实现功能。大大提高开发效率。
2、三层架构
表现层：
是用于展示数据的
业务层：
是处理业务需求
持久层：
是和数据库交互的
3、持久层技术解决方案
JDBC技术：
Connection
PreparedStatement
ResultSet
Spring的JdbcTemplate：
Spring中对jdbc的简单封装
Apache的DBUtils：
它和Spring的JdbcTemplate很像，也是对Jdbc的简单封装

以上这些都不是框架
JDBC是规范
Spring的JdbcTemplate和Apache的DBUtils都只是工具类

4、mybatis的概述
mybatis是一个持久层框架，用java编写的。
它封装了jdbc操作的很多细节，使开发者只需要关注sql语句本身，而无需关注注册驱动，创建连接等繁杂过程
它使用了ORM思想实现了结果集的封装。

ORM：
Object Relational Mappging 对象关系映射
简单的说：
就是把数据库表和实体类及实体类的属性对应起来
让我们可以操作实体类就实现操作数据库表。

user      User
id      userId
user_name   userName

今天我们需要做到
实体类中的属性和数据库表的字段名称保持一致。
user User
id id
user_name user_name
5、mybatis的入门
mybatis的环境搭建
第一步：创建maven工程并导入坐标
第二步：创建实体类和dao的接口
第三步：创建Mybatis的主配置文件
SqlMapConifg.xml
第四步：创建映射配置文件
IUserDao.xml
环境搭建的注意事项：
第一个：创建IUserDao.xml 和 IUserDao.java时名称是为了和我们之前的知识保持一致。
在Mybatis中它把持久层的操作接口名称和映射文件也叫做：Mapper
所以：IUserDao 和 IUserMapper是一样的
第二个：在idea中创建目录的时候，它和包是不一样的
包在创建时：com.itheima.dao它是三级结构
目录在创建时：com.itheima.dao是一级目录
第三个：mybatis的映射配置文件位置必须和dao接口的包结构相同
第四个：映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名
第五个：映射配置文件的操作配置（select），id属性的取值必须是dao接口的方法名

当我们遵从了第三，四，五点之后，我们在开发中就无须再写dao的实现类。

mybatis的入门案例
第一步：读取配置文件
第二步：创建SqlSessionFactory工厂
第三步：创建SqlSession
第四步：创建Dao接口的代理对象
第五步：执行dao中的方法
第六步：释放资源

注意事项：
  不要忘记在映射配置中告知mybatis要封装到哪个实体类中
  配置的方式：指定实体类的全限定类名

mybatis基于注解的入门案例：
  把IUserDao.xml移除，在dao接口的方法上使用@Select注解，并且指定SQL语句
  同时需要在SqlMapConfig.xml中的mapper配置时，使用class属性指定dao接口的全限定类名。

明确：
我们在实际开发中，都是越简便越好，所以都是采用不写dao实现类的方式。
不管使用XML还是注解配置。
但是Mybatis它是支持写dao实现类的。

6、自定义Mybatis的分析：
mybatis在使用代理dao的方式实现增删改查时做什么事呢？
只有两件事：
第一：创建代理对象
第二：在代理对象中调用selectList

自定义mybatis能通过入门案例看到类
class Resources
class SqlSessionFactoryBuilder
interface SqlSessionFactory
interface SqlSession

day02

1、回顾mybatis自定义和环境搭建+完善自定义Mybatis的注解开发
2、Mybatis基于代理Dao的CRUD操作 重点内容
3、CRUD中可能遇到的问题：参数的传递以及返回值的封装
4、介绍Mybatis基于传统dao方式的使用（自己编写dao的实现类） 了解的内容
5、mybatis主配置文件中的常用配置
properties标签
typeAliases标签 —解释Integer的写法
mappers标签的子标签：package

OGNL表达式：
Object Graphic Navigation Language
对象 图 导航 语言

它是通过对象的取值方法来获取数据。在写法上把get给省略了。
比如：我们获取用户的名称
  类中的写法：user.getUsername();
  OGNL表达式写法：user.username

mybatis中为什么能直接写username,而不用user.呢：
因为在parameterType中已经提供了属性所属的类，所以此时不需要写对象名

day03

1、mybatis中的连接池以及事务控制      原理部分了解，应用部分会用

mybatis中连接池使用及分析
mybatis事务控制的分析
2、mybatis基于XML配置的动态SQL语句使用 会用即可
mappers配置文件中的几个标签：
< if>
< where>
< foreach>
< sql>
3、mybatis中的多表操作 掌握应用
一对多
一对一（？）

多对多

1、连接池：
我们在实际开发中都会使用连接池。
因为它可以减少我们获取连接所消耗的时间。
2、mybatis中的连接池
mybatis连接池提供了3种方式的配置：
配置的位置：
主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式。
type属性的取值：
POOLED 采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现
UNPOOLED 采用传统的获取连接的方式，虽然也实现Javax.sql.DataSource接口，但是并没有使用池的思想。
JNDI 采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器所能拿到DataSource是不一样。
注意：如果不是web或者maven的war工程，是不能使用的。
我们课程中使用的是tomcat服务器，采用连接池就是dbcp连接池。
3、mybatis中的事务
什么是事务
事务的四大特性ACID
不考虑隔离性会产生的3个问题
解决办法：四种隔离级别

它是通过sqlsession对象的commit方法和rollback方法实现事务的提交和回滚
4、mybatis中的多表查询
表之间的关系有几种：
一对多
多对一
一对一
多对多
举例：
用户和订单就是一对多
订单和用户就是多对一
一个用户可以下多个订单
多个订单属于同一个用户

人和身份证号就是一对一
  一个人只能有一个身份证号
  一个身份证号只能属于一个人

老师和学生之间就是多对多
  一个学生可以被多个老师教过
  一个老师可以交多个学生

特例：
如果拿出每一个订单，他都只能属于一个用户。
所以Mybatis就把多对一看成了一对一。

mybatis中的多表查询：
示例：用户和账户
一个用户可以有多个账户
一个账户只能属于一个用户（多个账户也可以属于同一个用户）
步骤：
1、建立两张表：用户表，账户表
让用户表和账户表之间具备一对多的关系：需要使用外键在账户表中添加
2、建立两个实体类：用户实体类和账户实体类
让用户和账户的实体类能体现出来一对多的关系
3、建立两个配置文件
用户的配置文件
账户的配置文件
4、实现配置：
当我们查询用户时，可以同时得到用户下所包含的账户信息
当我们查询账户时，可以同时得到账户的所属用户信息

示例：用户和角色
  一个用户可以有多个角色
  一个角色可以赋予多个用户
步骤：
  1、建立两张表：用户表，角色表
    让用户表和角色表具有多对多的关系。需要使用中间表，中间表中包含各自的主键，在中间表中是外键。
  2、建立两个实体类：用户实体类和角色实体类
    让用户和角色的实体类能体现出来多对多的关系
    各自包含对方一个集合引用
  3、建立两个配置文件
    用户的配置文件
    角色的配置文件
  4、实现配置：
    当我们查询用户时，可以同时得到用户所包含的角色信息
    当我们查询角色时，可以同时得到角色的所赋予的用户信息

day04

1、Mybatis中的延迟加载
问题：在一对多中，当我们有一个用户，它有100个账户。
在查询用户的时候，要不要把关联的账户查出来？
在查询账户的时候，要不要把关联的用户查出来？

在查询用户时，用户下的账户信息应该是，什么时候使用，什么时候查询的。
在查询账户时，账户的所属用户信息应该是随着账户查询时一起查询出来。

什么是延迟加载
在真正使用数据时才发起查询，不用的时候不查询。按需加载（懒加载）
什么是立即加载
不管用不用，只要一调用方法，马上发起查询。

在对应的四种表关系中：一对多，多对一，一对一，多对多
一对多，多对多：通常情况下我们都是采用延迟加载。
多对一，一对一：通常情况下我们都是采用立即加载。

2、Mybatis中的缓存
什么是缓存
存在于内存中的临时数据。
为什么使用缓存
减少和数据库的交互次数，提高执行效率。
什么样的数据能使用缓存，什么样的数据不能使用
适用于缓存：
经常查询并且不经常改变的。
数据的正确与否对最终结果影响不大的。
不适用于缓存：
经常改变的数据
数据的正确与否对最终结果影响很大的。
例如：商品的库存，银行的汇率，股市的牌价。
Mybatis中的一级缓存和二级缓存
一级缓存：
它指的是Mybatis中SqlSession对象的缓存。
当我们执行查询之后，查询的结果会同时存入到SqlSession为我们提供一块区域中。
该区域的结构是一个Map。当我们再次查询同样的数据，mybatis会先去sqlsession中
查询是否有，有的话直接拿出来用。
当SqlSession对象消失时，mybatis的一级缓存也就消失了。

二级缓存:
  它指的是Mybatis中SqlSessionFactory对象的缓存。由同一个SqlSessionFactory对象创建的SqlSession共享其缓存。
  二级缓存的使用步骤：
    第一步：让Mybatis框架支持二级缓存（在SqlMapConfig.xml中配置）
    第二步：让当前的映射文件支持二级缓存（在IUserDao.xml中配置）
    第三步：让当前的操作支持二级缓存（在select标签中配置）

3、Mybatis中的注解开发
环境搭建
单表CRUD操作（代理Dao方式）
多表查询操作
缓存的配置

SpringMVC

关于三层架构和 MVC

三层架构

我们的开发架构一般都是基于两种形式，一种是 C/S 架构，也就是客户端/服务器，另一种是 B/S 架构，也就 是浏览器服务器。在 JavaEE 开发中，几乎全都是基于 B/S架构的开发。那么在 B/S架构中，系统标准的三层架构 包括：表现层、业务层、持久层。三层架构在我们的实际开发中使用的非常多，所以我们课程中的案例也都是基于
三层架构设计的。 三层架构中，每一层各司其职，接下来我们就说说每层都负责哪些方面： 表现层： 也就是我们常说的web层。它负责接收客户端请求，向客户端响应结果，通常客户端使用http协议请求 web 层，web 需要接收 http 请求，完成 http 响应。 表现层包括展示层和控制层：控制层负责接收请求，展示层负责结果的展示。 表现层依赖业务层，接收到客户端请求一般会调用业务层进行业务处理，并将处理结果响应给客户端。 表现层的设计一般都使用 MVC 模型。（MVC 是表现层的设计模型，和其他层没有关系） 业务层： 也就是我们常说的 service 层。它负责业务逻辑处理，和我们开发项目的需求息息相关。web 层依赖业 务层，但是业务层不依赖 web 层。 业务层在业务处理时可能会依赖持久层，如果要对数据持久化需要保证事务一致性。（也就是我们说的， 事务应该放到业务层来控制） 持久层： 也就是我们是常说的 dao 层。负责数据持久化，包括数据层即数据库和数据访问层，数据库是对数据进 行持久化的载体，数据访问层是业务层和持久层交互的接口，业务层需要通过数据访问层将数据持久化到数据库
中。通俗的讲，持久层就是和数据库交互，对数据库表进行曾删改查的

MVC模型

MVC 全名是 Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写， 是一种用于设计创建 Web 应用程序表现层的模式。MVC 中每个部分各司其职： Model（模型）： 通常指的就是我们的数据模型。作用一般情况下用于封装数据。 View（视图）： 通常指的就是我们的 jsp 或者 html。作用一般就是展示数据的。 通常视图是依据模型数据创建的。
Controller（控制器）： 是应用程序中处理用户交互的部分。作用一般就是处理程序逻辑的。 它相对于前两个不是很好理解，这里举个例子： 例如： 我们要保存一个用户的信息，该用户信息中包含了姓名，性别，年龄等等。 这时候表单输入要求年龄必须是 1~100 之间的整数。姓名和性别不能为空。并且把数据填充 到模型之中。 此时除了 js 的校验之外，服务器端也应该有数据准确性的校验，那么校验就是控制器的该做 的。 当校验失败后，由控制器负责把错误页面展示给使用者。 如果校验成功，也是控制器负责把数据填充到模型，并且调用业务层实现完整的业务需求。

SpringMVC 是什么

SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架，属于 Spring FrameWork 的后续产品，已经融合在 Spring Web Flow 里面。Spring 框架提供了构建 Web 应用程序的全功 能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用 Spring 进行 WEB 开发时，可以选择使用 Spring 的 Spring MVC 框架或集成其他 MVC 开发框架，如 Struts1(现在一般不用)，Struts2 等。 SpringMVC 已经成为目前最主流的 MVC 框架之一，并且随着 Spring3.0 的发布，全面超越 Struts2，成 为最优秀的 MVC 框架。 它通过一套注解，让一个简单的 Java 类成为处理请求的控制器，而无须实现任何接口。同时它还支持 RESTful 编程风格的请求.

SpringMVC的优势

1、清晰的角色划分：
前端控制器（DispatcherServlet）
请求到处理器映射（HandlerMapping）
处理器适配器（HandlerAdapter）
视图解析器（ViewResolver）
处理器或页面控制器（Controller）
验证器（ Validator）
命令对象（Command 请求参数绑定到的对象就叫命令对象）
表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）。

2、分工明确，而且扩展点相当灵活，可以很容易扩展，虽然几乎不需要。
3、由于命令对象就是一个 POJO，无需继承框架特定 API，可以使用命令对象直接作为业务对象。
4、和 Spring 其他框架无缝集成，是其它 Web 框架所不具备的。
5、可适配，通过 HandlerAdapter 可以支持任意的类作为处理器。
6、可定制性，HandlerMapping、ViewResolver 等能够非常简单的定制。
7、功能强大的数据验证、格式化、绑定机制。
8、利用 Spring 提供的 Mock 对象能够非常简单的进行 Web 层单元测试。 9、本地化、主题的解析的支持，使我们更容易进行国际化和主题的切换。
10、强大的 JSP 标签库，使 JSP 编写更容易。 ………………还有比如RESTful风格的支持、简单的文件上传、约定大于配置的契约式编程支持、基于注解的零配 置支持等等。

入门案例涉及的组件

1.DispatcherServlet：前端控制器：用户请求到达前端控制器，它就相当于 mvc 模式中的 c，dispatcherServlet 是整个流程控制的中心，由 它调用其它组件处理用户的请求，dispatcherServlet 的存在降低了组件之间的耦合性。

2.HandlerMapping：处理器映射器 。HandlerMapping 负责根据用户请求找到 Handler 即处理器，SpringMVC 提供了不同的映射器实现不同的 映射方式，例如：配置文件方式，实现接口方式，注解方式等。

3.Handler：处理器 。它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由 Handler 对具体的用户请求进行处理。

4.HandlAdapter：处理器适配器 。通过 HandlerAdapter 对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理 器进行执行。

5.View Resolver：视图解析器
View Resolver 负责将处理结果生成 View 视图，View Resolver 首先根据逻辑视图名解析成物理视图名 即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。

6.View：视图
SpringMVC 框架提供了很多的 View 视图类型的支持，包括：jstlView、freemarkerView、pdfView 等。我们最常用的视图就是 jsp。 一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由程序员根据业务需求开发具体的页面

响应数据和结果视图

controller 方法返回字符串可以指定逻辑视图名，通过视图解析器解析为物理视图地址。

SpringMVC中的拦截器

Spring MVC 的处理器拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理。 用户可以自己定义一些拦截器来实现特定的功能。 谈到拦截器，还要向大家提一个词——拦截器链（Interceptor Chain）。拦截器链就是将拦截器按一定的顺 序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。 说到这里，可能大家脑海中有了一个疑问，这不是我们之前学的过滤器吗？是的它和过滤器是有几分相似，但是也有区别，接下来我们就来说说他们的区别： 过滤器是 servlet 规范中的一部分，任何 java web 工程都可以使用。 拦截器是 SpringMVC 框架自己的，只有使用了 SpringMVC 框架的工程才能用。 过滤器在 url-pattern 中配置了/*之后，可以对所有要访问的资源拦截。 拦截器它是只会拦截访问的控制器方法，如果访问的是 jsp，html,css,image 或者 js 是不会进行拦 截的。 它也是 AOP 思想的具体应用。 我们要想自定义拦截器， 要求必须实现：HandlerInterceptor 接口。

SpringMVC 和 Struts2 的优略分析

共同点： 它们都是表现层框架，都是基于 MVC 模型编写的。 它们的底层都离不开原始 ServletAPI。 它们处理请求的机制都是一个核心控制器。 区别： Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter Spring MVC 是基于方法设计的，而 Struts2 是基于类，Struts2 每次执行都会创建一个动作类。所 以 Spring MVC 会稍微比 Struts2 快些。 Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便 (JSR303 是一套 JavaBean 参数校验的标准，它定义了很多常用的校验注解，我们可以直接将这些注 解加在我们 JavaBean 的属性上面，就可以在需要校验的时候进行校验了。) Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些，但执行效率并没有比 JSTL 提 升，尤其是 struts2 的表单标签，远没有 html 执行效率高。

Spring是什么

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control： 反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多 著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

Spring的发展历程及优势

1997 年 IBM提出了EJB 的思想
1998 年，SUN制定开发标准规范 EJB1.0
1999 年，EJB1.1 发布
2001 年，EJB2.0 发布
2003 年，EJB2.1 发布
2006 年，EJB3.0 发布 Rod Johnson（spring之父）
Expert One-to-One J2EE Design and Development(2002) 阐述了 J2EE 使用EJB 开发设计的优点及解决方案 Expert One-to-One J2EE Development without EJB(2004) 阐述了 J2EE 开发不使用 EJB的解决方式（Spring 雏形）
2017 年 9 月份发布了 spring 的最新版本 spring 5.0 通用版（GA）

优势：
方便解耦，简化开发。 通过 Spring提供的 IoC容器，可以将对象间的依赖关系交由 Spring进行控制，避免硬编码所造 成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可 以更专注于上层的应用。

AOP编程的支持 通过 Spring的 AOP 功能，方便进行面向切面的编程，许多不容易用传统OOP 实现的功能可以通过 AOP 轻松应付。

声明式事务的支持 可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理， 提高开发效率和质量。

方便程序的测试 可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可 做的事情。

方便集成各种优秀框架 Spring可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz 等）的直接支持。 降低 JavaEE API的使用难度 Spring对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的 使用难度大为降低。

Java源码是经典学习范例 Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java 设计模式灵活运用以 及对 Java技术的高深造诣。它的源代码无意是 Java 技术的最佳实践的范例。

IOC的概念

控制反转（Inversion of control）把创建对象的权利交给框架，是框架的重要特征。它包括依赖注入和依赖查找。

程序的耦合

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调 用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立 性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。 在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个 准则就是高内聚低耦合。

工厂模式解耦

在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。 那么，这个读取配置文件，创建和获取三层对象的类就是工厂。

IOC中的标签

一、bean标签
作用： 用于配置对象让 spring 来创建的。 默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。 属性：
id：给对象在容器中提供一个唯一标识。用于获取对象。 class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
scope：指定对象的作用范围。

* singleton :默认值，单例的.   
* prototype :多例的.  
* request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中. 
* session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.  
* global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么 globalSession 相当于 session. 

init-method：指定类中的初始化方法名称。
destroy-method：指定类中销毁方法名称。

bean 的作用范围和生命周期 ：
单例对象：scope=”singleton” 一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期： 对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
多例对象：scope=”prototype” 每次访问对象时，都会重新创建对象实例。
生命周期：
对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

实例化Bean的三种方式：
第一种方式：使用默认无参构造函数

第二种方式：spring管理静态工厂-使用静态工厂的方法创建对象

第三种方式：spring管理实例工厂-使用实例工厂的方法创建对象。
/** 模拟一个实例工厂，创建业务层实现类 此工厂创建对象，必须现有工厂实例对象，再调用方法 */
< !– 此种方式是： 先把工厂的创建交给 spring 来管理。 然后在使用工厂的 bean 来调用里面的方法 factory-bean 属性：用于指定实例工厂 bean 的 id。 factory-method 属性：用于指定实例工厂中创建对象的方法。 –>

spring 的依赖注入

依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。 我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。 ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。 那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。 简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

1.使用构造函数的方式，给 service 中的属性传值。
要求： 类中需要提供一个对应参数列表的构造函数。
涉及的标签： constructor-arg
属性：
index:指定参数在构造函数参数列表的索引位置
type:指定参数在构造函数中的数据类型
name:指定参数在构造函数中的名称 用这个找给谁赋值
=======上面三个都是找给谁赋值，下面两个指的是赋什么值的==============
value:它能赋的值是基本数据类型和 String 类型 ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean 。

2. 通过配置文件给 bean 中的属性传值：使用 set 方法的方式
   属性：
   name：找的是类中 set 方法后面的部分
   ref：给属性赋值是其他 bean 类型的
   value：给属性赋值是基本数据类型和 string 类型的
   (实际开发中，此种方式用的较多)。

spring整合junit分析

1、应用程序的入口
main方法
2、junit单元测试中，没有main方法也能执行
junit集成了一个main方法
该方法就会判断当前测试类中哪些方法有 @Test注解
junit就让有Test注解的方法执行
3、junit不会管我们是否采用spring框架
在执行测试方法时，junit根本不知道我们是不是使用了spring框架
所以也就不会为我们读取配置文件/配置类创建spring核心容器
4、由以上三点可知
当测试方法执行时，没有Ioc容器，就算写了Autowired注解，也无法实现注入

Java没Virtual虚函数的

java中没有virtual这个关键字,virtual是C++中用来声明虚函数时用的. C++中用虚函数来表现多态性。
Java中没有Virtual关键字，没有虚方法的概念。在Java中，如果函数不是抽象函数，而是一个普通函数，它是默认实现类似C#中虚函数功能的。也就是说，调用某个函数，是根据当前指针所指向对象的类型来判断的，而不是根据指针类型判断。正好与C#中的普通函数相反。即：JAVA里自动实现了虚函数。

Java构造函数

1.构造器必须与类同名（如果一个源文件中有多个类，那么构造器必须与公共类同名）
2.每个类可以有一个以上的构造器
3.构造器可以有0个、1个或1个以上的参数
4.构造器没有返回值
5.构造器总是伴随着new操作一起调用

Java中delete的使用

如果 “D:/defonds/temp” 是一个空目录的话，可以成功删除。但是如果是一个非空目录的话，就无法成功删除，必须将其子文件（目录）删除干净才可删除成功。使用以下的方法可以成功删除非空文件夹：

或者

class类中的newInstance()和new()方法（方法每次都会初始化）

1.new 是java中的关键字，是创建一个新对象的关键字。用new这个关键字的话，是调用new指令创建一个对象，然后调用构造方法来初始化这个对象，如果反编译class的话，会看到一个Object obj=new Object();这种语句，会先调用new指令生成一个对象，然后调用dup来复制对象的引用，最后调用Object的构造方法。
2.newInstance 不是关键字，newInstance() 是java反射框架中类对象(Class)创建新对象的方法。在这个过程中，是先取了这个类的不带参数的构造方法，然后调用构造方法的newInstance来创建对象名：Object java.lang.Class.newInstance();如: Class clazz = String.class;Object newInstance = clazz.newInstance();
3.newInstance() 也经常见于工厂设计模式中，在该模式中，共产类的该方法返回一个工厂bean。如： Factory factory = new Factory();Object obj = factory.newInstance()。

核心两个接口的容器

1.ApplicationContext（单例对象适用）：它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件就立即创建配置文件中配置的对象；
2.BeanFactory（多例对象适用）：它在构建核心容器时，创建对象采取的策略是延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。

String和StringBuild和StringBuffer区别

String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

length()方法，length属性和 size() 方法的区别:

1、length() 方法是针对字符串来说的，要求一个字符串的长度就要用到它的length()方法；
2、length 属性是针对 Java 中的数组来说的，要求数组的长度可以用其 length 属性；
3、Java 中的 size() 方法是针对泛型集合说的, 如果想看这个泛型有多少个元素, 就调用此方法来查看!

JSON.parse() 方法用于将一个 JSON 字符串转换为对象。

语法：JSON.parse(text[, reviver])
参数说明：
text:必需， 一个有效的 JSON 字符串。
reviver: 可选，一个转换结果的函数， 将为对象的每个成员调用此函数。
返回值：返回给定 JSON 字符串转换后的对象。

但是如果使用JSON.parse()方法来转化json对象，需要注意的坑点是什么？

1.字符串的数据格式
str = ‘{“name”:”小明”,”age”:18}’; 属性name和age都用双引号引住，
有的人可能会习惯写成对象形式的字符串，如：str = ‘{name:”小明”,age:18}’;
结果使用JSON.parse()来转化会报错，因为使用JSON.parse需严格遵守JSON规范。

2.单引号与双引号
var str = ‘{“name”:”小明”,”age”:18}’; 使用单引号来套双引号，如果反过来写呢，如：var str = “{‘name’:’小明’, ‘age’:18}”;（相信也不少人习惯用双引号套单引号）
结果使用JSON.parse()来转化也会报错

最后总结来说，如果使用JSON.parse()方法来转化成json对象的数据格式的话，需要注意的是被转化的字符串里面的属性要使用引号，并且总体是单引号套双引号的方式。

小程序

什么是小程序？

1.无需下载，用完即走（体积太小，刚发布的压缩包体积最大不能超过1M，2017年4月将1M提升为2M）

小程序特点？

1.体积小
2.同app进行互补的，可以实现app的基本功能
3.微信扫一扫或者搜索就可以下载
4.开发周期短，成本较低

适配方案

1.viewport适配 width=device-width
2.单位：rpx
3.iphone6:1rpx=1物理像素=0.5px dpr=物理像素/设备独立像素=2

重要的文件

1.wxml view结构 ——->html
2.wxss view样式 ——->css
3.js view行为 ——->js
4.json文件：数据&&配置

注册小程序：App（）

注册页面：Page（）

数据绑定：

1.在data中初始化页面需要的数据，在页面中可以直接使用

事件（冒泡事件 || 非冒泡事件）

1.冒泡事件：bind+事件名
2.非冒泡事件：catch+事件名

模板template

1.定义：template 属性：name(标识模板)
2.使用：template 属性：is(模板的name)
3.引入模板结构：
4.引入模板样式：@import’路径’

列表渲染

1.wx:for
2.wx:key为每一个个体元素进行标记
3.遍历的个体：item
4.遍历的下标：index

本地缓存（setStorage,setStorageSync)

1.缓存的用户是否收藏当前文章：{0：true，1：false}
2.注意：
a.缓存之前应该先去获取之前本地缓存的数据
b.缓存的新数据是在原有数据的基础上进行的
c.当页面加载的时候onLoad中获取本地缓存的数据（动态修改当前页面是否收藏文章的状态）
d.如果storage中没有缓存过通过key获取的Value为空
e.如果用户之前没有缓存过的话：初始化一个空对象在storage中

音乐播放

1.如何知道音乐在播放或者暂停
2.将播放音乐的页面状态缓存到appData

Vue.js含义

Vue (读音 /vjuː/，类似于 view) 是一套用于构建用户界面的渐进式框架。与其它大型框架不同的是，Vue 被设计为可以自底向上逐层应用。Vue 的核心库只关注视图层，不仅易于上手，还便于与第三方库或既有项目整合。另一方面，当与现代化的工具链以及各种支持类库结合使用时，Vue 也完全能够为复杂的单页应用提供驱动。学此框架的原因是正学习微信小程序的开发，学习到一半了解到这语法和vue语法很像，学过vue学小程序会更容易。

Vue.js语法

1.挂载点、模板及实例

挂载点：el属性(#root)对应后面id(id=”root”)所对应的节点,div标签就是Vue实例的挂载点（因为实例中的el与div中的id对应）；
模版： 指的是挂载点内部，也可以写在实例里面template属性里面;
实例：Vue会结合模版和数据生成最终要展示的内容，然后把放在挂载点之中。
ps: 实例中el:”#root”表示Vue接管的是 上面

2.数据、事件和方法
如上述代码，v-on是一个事件，handleclick是一个函数方法且在实例中定义，表示一点击content的内容就把content变成world。
v-html = “数据名” 输出<标签> 和 文本v-text = “数据名” 输出纯文本 ,
标签也会转义为文本。v-html与v-text的区别是，v-html不会转义，而v-text会转译；
v-on:click=”handleClick”：通过v-on给元素绑定一个Click事件，事件触发方法。v-on:click的简写方法：@click。 @click=”方法名”
在当前标签中绑定一个点击事件,方法在methods中声明new Vue中的this是指这个 Vue实例 ,指它自己’’this.data.属性名’’ 指 “Vue
里的 data 里的 属性”。

3.Vue中的属性绑定和双向数据绑定
v-bind：属性绑定。缩写为冒号 : (:title)
v-model：双向数据绑定，随着数据的修改与之对应的也会修改。

4.Vue中的计算属性和侦听器
1.计算属性(computed:)：一个属性通过其他属性计算而来
好处：（只有它依赖的数据发生变化的时候，它才会重新计算；如果依赖的属性没有发生变化，它会利用以前计算结果的缓存来在页面上做显示）

2.侦听器(watch)：指的是监听某一个数字发生了变化，然后就在监听器里面做业务逻辑，侦听器watch：监测某一个数据或计算属性发生了变化，一旦这个数据发生了变化，就在该侦听器内写入业务逻辑。注：watch不仅可以监听vue实例的data内属性，而且可以监听计算computed下计算属性的变化

5.v-if,v-show,v-for指令
v-if：当对应data中的值show是true时显示，为false，则把这个标签就移除。
v-if 和 v-show 用处：
1.v-show 不会像 v-if 每次销毁再重新创建，v-show 性能相对v-if 高一些；
2.如果标签显示的频率不是那么大，只需要做一次显示或者隐藏，这时候用 v-if 是一个更好的选择。
所以：
v-if:具有选择性的指令，可以是页面显示隐藏。
v-show:加的隐藏
v-for：循环遍历，注意添加key的属性它的值的内容必须是完全不同的

Vue.js的组件

1.todoList功能开发

Vue是在操作数据、点击提交，将input的内容放进数组中，如果数组有内容，列标签会自动循环，将数据输出。JQ是操作DOM, 而Vue是操作数据。一句话来说: key值是为了虚拟dom的比对。展开来说: 页面上的标签都对应具体的虚拟dom对象(虚拟dom就是js对象), 循环中 ,如果没有唯一key , 页面上删除一条标签, 由于并不知道删除的是那一条! 所以要吧全部虚拟dom重新渲染, 如果知道key为x标签被删除掉, 只需要把渲染的dom为x的标签去掉即可!

2.todoList组件拆分

3.组件和实例的关系
每一个vue组件都是一个vue实例。实例的模板里使用一个小的组件。每一个组件也可以写methods，data。因此每一个组件都是一个Vue的实例。如果不定义模板，就会根据挂载点下面的DOM标签标签全部内容当做模板。

4.实现todoList的删除功能
父组件向子组件传值，通过属性的方式传递，子组件中通过props接收。在子组件中通过$emit触发父组件的自定义事件（this.$emit(‘delete’,this.index)），子组件中通过监听事件的触发（@delete=”handleDelete”）进行相应的业务逻辑处理。
在子组件的方法中，发布一个事件this.$emit( ‘ 事件名 ‘ , this.属性) this.属性：需要传递的参数
在子组件标签中绑定一个事件,触发父组件里的方法 <子组件标签 @事件名=”方法名” > <子组件标签 />

Vue-cli的简介与使用

一、首先是安装配置

注意：my-project是你自己的项目名称
【用脚手架工具创建项目】
1、npm install -global vue-cli 全局安装vue脚手架工具 vue-cli
2、vue init webpack my_project 创建一个基于webpack模版的新项目
3、cd my-project 进入到项目目录
4、npm run dev 运行项目
5、项目运行成功点击进入http://localhost:8080没出错即成功

二、其次解读项目中各个文件

《人工智能自然语言处理技术如何运用到软件工程行业》

总所周知，语言是人类特有的功能，是人类智慧的体现，那么在人工智能时代，人们就期许把语言这个功能在机器上实现出来，那么机器就有了语言识别能力，机器可以听得懂可以理解人们说的话，这样就为用户体验开辟了新途径。在近期的Google Cloud Next 18大会上，Google推出了第一个Solution Product （行业解决方案产品）——Contact Center AI，其集虚拟助理、智能信息发掘和情感分析等功能于一身，不但帮助工作人员有效解决了问题而且提升了用户体验，展现了人工智能语言技术的新突破。貌似科幻小说里的场景变成了现实，但是想要维护好人与机器的关系，机器必须能够实现直观的、自然的语言交流，这对于NLP技术来说仍然是一个挑战。很多企业早就开始研究NLP，该项技术的出现几乎跟人工智能一样早，但是目前还处于起步阶段。语言是人们进行信息交流的首要工具，要想机器也具备同样的机制，就要理解人类语言的复杂性以及人类使用语言的行为习惯，其中情感分析、问题回答以及多任务学习是机器人逐渐成熟的重要途径。语言本质上是复杂的，一个正常人也要经过数年才能掌握一门陌生的语言。对于机器人而言，我们要想使用人工智能来解析给定的陈述，首先要实现情绪分析，比如，判断电影评价是正面的还是负面的，或者分析发话者是高兴的、生气的、惊讶的还是悲伤的等。从客户服务到在线社区审核再到算法交易，企业能够通过分析成千上万个推文或数百个产品评论，了解公众对产品的看法，对于企业来说，这个价值是很大的。人人都希望生活变得便利，很多人都希望智能机器人可以出现在我们的生活中，可以和我们说话、为我们做家务以及实现很多不可能的事情，那么要做这些事情必须让机器人能识别并听得懂我们所说的话，这就需要人工智能自然语言处理技术，只有通过这种技术才能让机器人听得明白我们说的并为我们服务。沟通不仅仅在人与人之间至关重要，在机器与机器、机器与人之间也至关重要。这说明了人工智能自然语言处理技术的重要性。人工智能有三大阶段：机器学习、机器智能、机器意识，这三个阶段每一个都需要人工智能自然语言处理技术，所以说无论在哪一个行业，人工智能自然语言处理技术都是很重要的。

1 首先创建一个新的存储库，记得勾选下面那个

2 右击项目git bash here
然后输入：git clone https://github.com/little-Arya/little-Arya.github.io.git(这是你的存储库那儿复制的地址 有一个克隆或下载可得到)
这样在你的项目文件里会多出一个和你的GitHub上创建的项目一样名字的文件

把项目文件里的其他文件全部复制到那个多出来的文件里 比如我的是TieBa

3 然后进入这个TieBa文件：cd TieBa回车

4 后输入命令：git add . (注意：add与.之间一有空格) //不但可以跟单一文件，还可以跟通配符，更可以跟目录。一个点就把当前目录下所有未追踪的文件全部add了

5 再输入git commit -m “提交信息” （提交的信息是你的项目说明）
例如：
　　git commit -m “first commit” //把文件提交到仓库

这时你要先全局配置好在git上的用户名和邮箱
点此可看配置命令
后输入此命令，如果之前配置好了则不需要了。

6 最后输入：git push -u origin master（此操作目的是把本地仓库push到github上面，此步骤需要你输入登录github上的帐号和密码）
完成后进入GitHub页面刷新即可。

java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。

第一个构造函数使用当前日期和时间来初始化对象：Date( )
第二个构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数：Date(long millisec)。
之前将时间存进数据库的时候，第一个表的时间是现在时间开始算的，第二个表就是1970年开始的，代码如下：
第一个表的：  Date curTime = new Date();
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
             String regtime = sdf.format(curTime);

第二个表的：Date time=new Date(1);
           SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置成mysql能识别的datetime形式
           String time1=sdf.format(time);

这两个时间的区别就是第二个Date：
public Date(long date)
Constructs a Date object using the given millisecondstime value. If the given milliseconds value contains timeinformation, the driver will set the time components to thetime in the default time zone (the time zone of the Java virtualmachine running the application) that corresponds to zero GMT.
Parameters:date - milliseconds since January 1, 1970, 00:00:00 GMT notto exceed the milliseconds representation for the year 8099.A negative number indicates the number of millisecondsbefore January 1, 1970, 00:00:00 GMT.

虽然贴吧做的不完善，但是现在可以发表话题，可以评论，当然登陆注册，以及访问某些页面的权限都设置了。

贴吧还没完善的地方：没有注销功能；以及注册权限：相同的用户名可以重复注册；查找功能。

做这个项目的心得：

这可以说是我独立完成的第一个项目。一开始懵懵懂懂，把登陆注册连接好数据库都花了几天时间，真是万事开头难，不过解决好的那一刻也是很开心的。后面的问题就是如何发帖，当时各种百度心里没谱，多种尝试理解之后就终于找到了门路，主要还是要存进数据库，然后从数据库读取出来到页面上，评论功能也是如此。这次最大的体验就是学以致用。学习到的东西其实不多，但是能用起来真的是才体现了它的作用。压力下才能进步吧，当一个功能做不出来的时候真是睡觉的时候还在想，时间一天天过去问题还没解决真的压力山大，会给自己压迫感。做这个项目我把具体的每个步骤都列出来了，就是做事有先后顺序，一个一个完成， 其实完善的路也是很长的，只是尽自己所能，对别人给的意见要珍惜。第一次做这个东西做出来了真的很开心，最后还设计页面，在网上找到了自己想要的类型，用CSS给做出来，很可惜的是除了页面的一些验证功能用了JS,就没怎么用了。

后面要继续努力花时间，完善了贴吧后把书城做好，学以致用才不会落后！