学习spring-day01

# 框架
框架是一系列已经完成的代码的集合，用于解决特定的问题。

框架表现为某些`.jar`包文件，在开发时，需要在开发环境中导入这些`.jar`文件，然后按照框架约定的语法和工作流程来编程。

每种框架都是为了解决某个特定的问题而存在的。
# Spring框架

## 作用

当在项目中需要某个对象时，不必再使用`new`关键字创建对象，而是通过**Spring容器**获取对象。

## 使用

1 创建`Maven Project`，在弹出的对话框中勾选`Create a simple……`，然后在下一个界面中填写`Group Id`、`Artifact Id`，并将`Packaging`选为`war`即可。
2 通过eclipse生成`web.xml`文件
3 添加`Spring`依赖：打开网页`maven.tedu.cn`（如果连接的不是公司的网络，换成`maven.aliyun.com`），搜索`spring-webmvc`，并在结果中找到`Group`为`org.springframework`，且`Artifact`为`spring-webmvc`的项，并选择版本，然后将配置代码粘贴到项目的`pom.xml`中（事先在`pom.xml`中自行添加`<dependencies>`节点）：
<!-- 配置依赖 -->
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>3.2.8.RELEASE</version>
</dependency>
</dependencies>
4 从FTP服务器下载`applicationContext.zip`并解压，得到`applicationContext.xml`，复制并粘贴到项目中的`src\main\resources`文件夹中。
5 在`applicationContext.xml`中添加配置：
<!-- id：自定义名称，用于获取对象 -->
<!-- class：需要Spring来创建哪个类的对象 -->
<bean 
id="date"
class="java.util.Date" />
6 编写代码，获取对象，测试运行：
public static void main(String[] args) {
// 确定配置文件的文件名
String fileName
= "applicationContext.xml";
// 加载配置文件，获取Spring容器
ApplicationContext ac
= new ClassPathXmlApplicationContext(
fileName);
// 从Spring容器中获取对象
// getBean()方法的参数是配置文件中的bean id
Date date = (Date) ac.getBean("date");
// 测试
System.out.println(date);
}
# 通过Spring获取对象
## 1 【重要】 类本身存在无参数的构造方法
以`Date`为例，这个类存在无参数的构造方法，所以，可以使用这样的配置：
<bean 
id="date"
class="java.util.Date" />

## 2 【了解】 类自身存在静态的工厂方法
以`Calendar`为例，在这个类中，存在`getInstance()`方法可以获取`Calendar`对象，并且，这个方法还是`static`的！
public abstract class Calendar {
public static Calendar getInstance() {
// ...
}
}
则配置：
<!-- factory-method：工厂方法的方法名称 -->
<bean 
id="calendar"
class="java.util.Calendar"
factory-method="getInstance" />
## 3 【了解】 其它类中有工厂方法
类自身不便于创建对象，而是通过其它类中的工厂方法（非静态）来创建对象的！
public interface IUserDao {
}
public class UserDaoImpl implements IUserDao {
}
public class UserDaoFactory {
public IUserDao getInstance() {
return new UserDaoImpl();
}
}

配置：
<!-- 先配置工厂类 -->
<!-- 再配置需要获取对象的类 -->
<!-- factory-bean：工厂类的bean id -->
<bean
id="userDaoFactory"
class="cn.tedu.spring.UserDaoFactory" />
<bean
id="userDaoImpl"
class="cn.tedu.spring.UserDaoImpl"
factory-bean="userDaoFactory"
factory-method="getInstance" />
# 关于Maven下载的jar包失败的解决方案
1 在eclipse中点击`Window`菜单中的`Preferences`菜单项，选择`Maven`分支下的`User Settings`，右侧显示的最后一项就是Maven本地存储路径，记住这个位置，在机房的学生机中，都在桌面的`home`的`.m2`中
2 关闭eclipse
3 找到本地存储路径，删除`.m2`文件夹，在Linux系统下，这个文件夹是隐藏的，请先设置为显示隐藏项目
4 打开eclipse
5 如果问题仍然存在，对项目点鼠标右键，依次选择`Maven` -> `Update Project`，并在弹出的对话框中勾选`Force Update ...`
# 关于Resource leak
leak表示内存泄漏甚至内存溢出！
当尝试释放某个对象所占用的资源，却无法释放时，就会导致内存泄漏！例如使用某个流之后，没有调用`close()`方法！这样，会导致某个对象一直存在于内存中，已经不再使用，而JVM却认为这个对象是有用的，一直不销毁它！就会导致这个对象无谓的占用内存！
所以，其实少量的内存泄漏是没有明显的危害的！
内存泄漏的终级表现就是内存溢出！
对于开发者而言，应该避免任何可能的内存泄漏，常规做法就是那些需要释放资源的对象，在使用完毕之后，及时释放，例如调用流的`close()`方法。
# 请描述“封装”这个概念
封装是“装”了再“封”的过程。
很多时候，也许需要传递或克隆多个数据，但是，为了易于处理，会把这些数据“装”起来：
public class User {
public String name;
public int age;
}
但是，仅仅只是装起来，可能会有问题：
        User user = new User();
user.age = 9527;
以上代码就表现出“合法却不合理”的现象！为了避免类的属性被随便访问，可以：
public class User {
private String name;
private int age;
}
使用更加“严格”的权限，就是将属性“封”起来了！
经过以上调整，类似`user.age = 9527;`的语法将不成立！当然，私有化的目的不是不允许使用，而是不允许随意使用，所以，还应该添加其它的访问方式：
public class User {
private String name;
private int age;
public void setAge(int age) {
this.age = age;
}
}
则访问方式就会变为：
User user = new User();
user.setAge(9527);
由于数据的访问会经过方法，而方法中是可以添加其它的判断逻辑的：
public class User {
private String name;
private int age;
public void setAge(int age) {
if (age >= 18 && age <= 50) {
this.age = age;
}
}
}
为了便于获取这个属性的值，还应该添加匹配的`get`方法：
public class User {
private String name;
private int age;
public void setAge(int age) {
if (age >= 18 && age <= 50) {
this.age = age;
}
}
public int getAge() {
return age;
}
}
以上代码，表现的是对类的属性进行封装，其实，工厂模式也是对类本身进行封装的表现！例如：
public cn.tedu.dao.IUserDao
[默认] cn.tedu.dao.UserDao
public cn.tedu.dao.UserDaoFactory
# 请问抽象类和接口的区别
这是2个不同的概念，一个是class，一个是interface。
语法区别：接口中所有的成员都是public的，属性都是static final的，方法都是abstract的，而抽象类中的成员的访问权限是没有约束的，属性也不一定是static final的，方法也可以是普通的方法；类与抽象类的关系是一对一的继承(extends)的关系，类与接口的关系是一对多的实现(implements)的关系；接口也继承(extends)接口，并且可以一继承多。
抽象类的本质是一个类，类，表示“类别”，接口表示的是“标准、行为模式、行为能力”。
类与抽象类是"子类 is a 抽象类"的关系，类与接口是"类 has 接口"的关系。
public class Person {}
public class Teacher extends Person {}
public class Student extends Person {}
public class Driver extends Person {}
public class Person implements 教, 学, 驾驶, 烹饪 {
private boolean 能否教书;
private boolean 能否烹饪;
}
public interface 教 {}
public interface 学 {}
public interface 驾驶 {}
public interface 烹饪 {}
# 关于static
`static`关键字用于修饰类的成员。
public class Person {
public static String name;
public static void run() {
}
public static class InnerClass {
}
public static interface InnerInterface {
}
}
`static`的特性：唯一，常驻。
被`static`修饰的成员会加载到内存中的静态域中，无论创建多少个这个类的对象，`static`成员都只会有1个！所以，通常也说静态成员是独立的，从语法上表现为例如`Person.name`这个方式来访问。
被`static`修饰的成员将最优先加载到内存中，并且不会被销毁，仅当显式的销毁对象或程序运行结束，该对象才会消失！