标签：四种 src mic 形式 分层 service 文档加载 业务逻辑 事件触发
例如现在有一个学生类，用上面四种方式创建对象！
学生类
package com.xbky.domain;
import java.io.Serializable;
public class Students implements Cloneable, Serializable {
private int sid; //学号
private String sname; //姓名
private String gender; //性别
private String birthday; //出生日期
private String major; //专业
//一定要保留这个默认的无参数的构造方法，否则spring也无法实例化。
public Students() {
}
public Students(int sid, String sname, String gender, String birthday, String major) {
this.sid = sid;
this.sname = sname;
this.gender = gender;
this.birthday = birthday;
this.major = major;
}
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getBirthday() {
return birthday;
}
public void setBirthday(String birthday) {
this.birthday = birthday;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public String toString() {
return "Students{" +
"sid=" + sid +
", sname='" + sname + '\'' +
", gender='" + gender + '\'' +
", birthday='" + birthday + '\'' +
", major='" + major + '\'' +
'}';
}
}
4种方法创建对象
package com.xbky.test;
/*
* Spring也不使用new来创建对象，是使用ioc容器来注入的。
*
* */
import com.xbky.domain.Students;
import java.io.*;
import java.lang.reflect.Constructor;
public class IocDemo {
public static void main(String[] args) throws Exception {
File file = new File("dest.data");
Students s1 = new Students(100,"宋小宝","男","1999-10-10","二人转");
System.out.println(s1);
//使用clone来创建对象。
Students s2 = (Students) s1.clone();
System.out.println(s2);
Students s3 = s1;
System.out.println(s1 == s2);
System.out.println(s3 == s1);
//反射怎么创建对象呢。大家仔细观察我没有使用new.使用了反射。
Class clazz = s1.getClass();
Constructor constructor = clazz.getConstructor(int.class,String.class,String.class,String.class,String.class);
Students s5 = (Students) constructor.newInstance(new Object[]{100,"小沈阳","女","1999-10-10","二人转"});
System.out.println(s5);
//反序列化创建对象。
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
out.writeObject(s1); //把宋小宝对象写入到文件中。
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
Students s6 = (Students) in.readObject();
System.out.println(s6);
System.out.println(s1 == s6);
}
}
没有使用new,内部也是通过反射+xml文档的解析来实现的
在resources创建一个applicationContext.xml文件
<bean id="s1" class="com.xbky.domain.Students">
<property name="sid" value="200"/>
<property name="sname" value="张三丰"/>
<property name="gender" value="男" />
<property name="birthday" value="1998-10-10"/>
<property name="major" value="太极拳" />
</bean>创建一个类注入对象测试
package com.xbky.test;
import com.xbky.domain.Students;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class IocDemo2 {
public static void main(String[] args) {
//使用了spring ioc 容器注入了一个对象。没有使用new.内部也是通过反射+xml文档的解析来实现的。
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Students s1 = (Students) context.getBean("s2");
System.out.println(s1);
}
}
Spring IOC执行的顺序
到resources下加载applicationContext.xml
解析这个xml文档
getBean（“s1”）从文档中解析到s1对象，使用java的反射机制，反射出一个对象出来返回
注意：属性的初始化是通过setXXX来实现的，对象的创建通过调用默认的无参数的构造方法去实现的，那么要求类必须要保留那个默认的无参数构造方法，否则Spring ICO容器也无法实例化对象。
IOC对象初始化的步骤
例子：依赖Service
<dependencies>
<dependency>
<groupId>com.shsxt</groupId>
<artifactId>wc-service</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
</dependencies>然后复制到pom.xml文件中，记得写在project便签和dependencies中，保存就依赖了
在 Maven 中需要定义一个 parent POM 作为一组 module 的聚合 POM。在该 POM 中可以使用 标签来定义一组子模块。 parent POM 不会有什么实际构建产出。 而 parent POM 中的 build 配置以及依赖配置都会自动继承给子 module。
例如子模块的pom.xml配置如下：
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.hbgc</groupId>
<artifactId>base</artifactId>
<version>1.0-SNAPSHOT</version>
<!--父模块的pom.xml位置-->
<relativePath>../base/pom.xml</relativePath>
</parent>
<groupId>com.hbgc</groupId>
<artifactId>springbootdemo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springbootdemo</name>
<description>Demo project for Spring Boot</description>添加插件，类似于添加依赖, 通过 GAV 来指定插件, 其中对于maven官方插件, 可以省略 GroupId。例如：
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-clean-plugin</artifactId>
<version>3.0.0</version>
</plugin>
</plugins>
</build>
与控制依赖版本类似, 可以通过引用属性和 pluginManagement 对项目中的插件版本进行统一管理。注意 pluginManagement 元素需要放在 build 元素之下。
例如：
<build>
<pluginManagement>
<plugins>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.0.0</version>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.20.1</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.0</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
</plugins>
</pluginManagement>
</build>在idea中，我们可以打开maven project视图。在maven的生命周期列表中进行测试、打包和安装
MVC是一个架构，或者说是一个设计模式，它就是强制性使应用程序的输入，处理和输出分开。
将一个应用程序分为三个部分
原理图
分析：
MVC的优点
? Dependency Inject ,依赖注入。
面向切面编程，简单地说就是在不改变原程序的基础上为代码段增加新功能，对代码段进行增强处理
Inverse of Controller：控制反转，把创建对象的操作交给框架，所以又被称为依赖注入
Dependency Inject ,依赖注入。
setter方式注入
创建学生类创建学生类，给予学生类一个学号，一个姓名的属性（此两个属性必须生成set方法，才能完成setter方式的注入）
public class Student {
//学号
private int num;
//姓名
private String name;
public void setNum(int num) {
this.num = num;
}
public void setName(String name) {
this.name = name;
}
}在applicationContext.xml文件中赋值
<!-- setter方法注入 -->
<bean id="stu" class="Student" >
<property name="num" value="1"></property>
<property name="name" value="李四"></property>
</bean>构造注入
给学生类写个带参的构造函数（写完带参的构造函数后，必须再定义一个无参的构造函数）
//构造器注入
public class Student {
public Student(){
}
public Student(int num,String name){
}
//学号
private int num;
//姓名
private String name;
}在applicationContext.xml文件中赋值
<!-- 构造器注入 -->
<bean id="st" class="Student">
<constructor-arg>
<value type="java.lang.int">101</value>
</constructor-arg>
<constructor-arg>
<value type="java.lang.String">张三</value>
</constructor-arg>
</bean>使用P命名空间注入
在Student最基础类的基础上，给ApplicationContext.xml文件中导入一个头的包
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
</beans>之后再xml用bean标签赋值
<bean id="stu" class="test.Student" p:name="张三" p:num="1001">
</bean>面向接口编程：
面向对象编程中不同的对象协作完成系统的各个功能，对象内部的实现由各个类自己实现。但是随着系统愈发杂，对象内部功能的实现已经不那么重要了（类自己内部实现），反之对象间的协作能力更为重要，这就是面向接口编程的思想
面向接口编程:
就是先将业务的逻辑线先提取出来，作为接口，而将具体的代码实现作为实现类来完成。当客户需变化时，只用更改接口下的实现类就可以
面向接口编程优点：
抽象类和接口的选择
在于使用动机，使用抽象类是为了代码的复用，而使用接口的动机是为了实现多态性与协作关系
面向接口编程
经典的面向接口编程例子-JDBC
SUN公司提供了JDBC接口的规范，而不同的数据库厂商开发不同的数据库驱动
可以理解为只有实现者和调用者都遵循"面向接口编程"这个准则，制定者的协调目的才能达到
同步：提交请求->等待服务器处理->处理完毕返回，在此期间浏览器不能做别的事情
异步：请求通过事件触发->服务器处理（服务器任然可以做别的事情）->处理完毕
区别：
同步提交的时候客户端浏览器不能做别的事情，只能等待服务器处理；而异步提交的时候客户端浏览器任然可以做别的
可以理解为吃饭，同步就是我叫你去吃饭，你没听见，我继续叫你，知道你回答我了，一起去吃饭。
异步就是我给你发消息说我去吃饭了，然后我就先走了，你后面自己来
标签：四种 src mic 形式 分层 service 文档加载 业务逻辑 事件触发
原文地址：https://www.cnblogs.com/godles/p/12334115.html
