1、什么是框架： 2、如何学习框架： 3、Spring是什么：
4、Spring的优势： 5、 Spring结构
6、Spring核心概念（loC)控制反转: 7、Spring入门案例：
8、Spring核心-loc：非自定义对象的创建 9、Spring核心-loc：创建对象的三种方式
10、Spring核心-loc-基于xml的DI 11、Spring核心-IoC-基于注解实现IoC
12、 Spring核心-IoC-属性注入的注解实现 13、Spring核心-IoC-总结
1、什么是框架：
在软件设计中指为解决一个开放性问题而 设计的具有一定约束性的支撑结构。在此结构上 可以根据具体问题扩展、安插更多的组成部分，从而更 迅速和方便地构建完整的解决问题 的方案。
2、如何学习框架：
1）知道框架能做什么
2）学习框架的语法，一般框架完成一个功能需要一定的步骤
5、 Spring体系结构：Spring 为我们提供了一站式解决方案，但Spring 是模块化的，允许咱们挑
选和选择适用于项目的模块， 不需要把剩余部分也引入。 Spring 框架提供约 20 个模块，
可以根据应用程序的要求来选择。
6、Spring核心概念（loC)控制反转:
1）Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。 IoC 是
指在程序开发中，实例的创建不再由调用者管理，而是由 Spring 容器创建。Spring 容器 会负责控 制程序之间的关系，而不是由程序代码直接控制，因此，控制权由程序代码转 移到了 Spring 容器中，控 制权发生了反转，这就是 Spring 的 IoC 思想。
7、Spring入门案例：
1）目的：让Spring自己去给我们创建一个对象
2）流程：
1…创建一个实体类Team
2…在java包下的resource下创建一个 Spriing 的 XML 文件
import com.zj.bean.Team;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.FileSystemResource;
public class Test01 {
@Test
public void test01(){
//没有使用Spring时候测试 Team team = new Team();
//使用 Spring 容器创建对象
//1.获得配置文件的名字
String springConfig = "application.xml";
//2.获取容器
//这句话执行完毕，我们就得到了类的对象了
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(springConfig);
//获取类的对象
Team team = (Team) applicationContext.getBean("team");
//Spring中常用的API
//获取配置文件中对象的个数
int count = applicationContext.getBeanDefinitionCount();
System.out.println(count);
//获取配置文件中对象的名字
String[] names = applicationContext.getBeanDefinitionNames();
for (String name : names) {
System.out.println(name);
}
//方式二：创建对象
BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource("配置文件的绝对路径"));
beanFactory.getBean("team");
//方式三：创建对象
ApplicationContext applicationContext1 = new FileSystemXmlApplicationContext("配置文件的绝对路径");
}
}
8、Spring核心-loc：非自定义对象的创建
和自定义的对象是相同的操作
在application.xml中：<bean id="date" class="java.util.Date"></bean>
在测试类中：applicationConfig.getBean("date");
9、bean标签的属性：
实例演示：
public void init() {
System.out.println("Team ---- init()");
}
public void destroy() {
System.out.println("Team ---- destroy()");
} <!--bean标签的属性:
id="自定义的对象名称" ,要求唯一
name="bean对于的一个标识“，一般使用id居多
class="类的完全限定名"
scope="singleton/prototype" 单例/多例
singleton：默认值，单例：在容器启动的时候就已经创建了对象，而且整个容器只有为一个 的一个对象
prototype：多例，在使用对象的时候才创建对象，每次使用都创建新的对象
lazy-init="true/false" 是否延迟创建对象，只针对单例有效
false:不延迟创建对象，容器加载的时候立即创建
true:默认加载，使用对象的时候才去创建对象
init-method="创建对象之后执行的初始化方法"
destroy-method="对象销毁方法，调用容器destroy方法的时候执行" -->
<bean id="team2" class="com.kkb.pojo.Team" scope="singleton" lazy- init="true" init-method="init"
destroy-method="destroy"/>
<bean id="team3" class="com.kkb.pojo.Team" scope="prototype"/> @Test
public void test02() {
String springConfig = "application.xml";
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(springConfig);
Team team1 = (Team) applicationContext.getBean("team1");
Team team11 = (Team) applicationContext.getBean("team1");
System.out.println(team1);
System.out.println(team11);
Team team2 = (Team) applicationContext.getBean("team2");
Team team22 = (Team) applicationContext.getBean("team2");
System.out.println(team2);
System.out.println(team22);
applicationContext.close();//关闭容器 }
}9、Spring核心-loc：创建对象的三种方式
1、创建工厂实体类
public class MyFactory {
/**
* 实例方法
* @return
*/
public Team instanceFun(){
return new Team(1,"勇士","荆州");
}
/**
* 静态方法
* @return
*/
public static Team staticFun(){
return new Team(2,"小牛","迈阿密");
}
// public static void main(String[] args) {
// //创建静态对象
// Team team01 = MyFactory.staticFun();
// //创建实例对象
// MyFactory myFactory = new MyFactory();
// Team team02 = myFactory.instanceFun();
//
// }
}
2、配置文件createType.xml
<!--
创建对象的三种方法：
1、通过默认的构造方法
2、通过带参的构造方法
3、通过工厂方法
-->
<!-- 1、通过默认的构造方法-->
<bean id="team01" class="com.zj.bean.Team"></bean>
<!-- 2、通过带参的构造方法-->
<bean id="team02" class="com.zj.bean.Team">
<!--index:表示参数的下标索引值-->
<constructor-arg index="0" value="01"/>
<constructor-arg index="1" value="勇士队"/>
<constructor-arg index="2" value="荆州"/>
</bean>
<bean id="team03" class="com.zj.bean.Team">
<!--name：表示对象的属性-->
<constructor-arg name="id" value="02"/>
<constructor-arg name="name" value="公牛"/>
<constructor-arg name="location" value="迈阿密"/>
</bean>
<!-- 3、通过工厂方法-->
<!--3.1、通过静态的方法 Team team01 = MyFactory.staticFun();-->
<bean id="staticTeam" class="com.zj.bean.MyFactory" factory-method="staticFun"></bean>
<!--3.2、通过实例的方法
MyFactory myFactory = new MyFactory();
Team team02 = myFactory.instanceFun();
-->
<!--创建一个对象-->
<bean id="myFactory" class="com.zj.bean.MyFactory"></bean>
<bean id="instanceFun" factory-bean="myFactory" factory-method="instanceFun"></bean>
</beans>3、测试类
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class createTypeTest {
@Test
public void test01(){
ApplicationContext ac = new ClassPathXmlApplicationContext("createType.xml");
}
}
10、Spring核心-loc-基于xml的DI
1）DI：Dependency Injection，即“依赖注入”：是组件之间依赖关系由容器在运行期决定，形象的 说，即 由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统 带来更多功能，而是为 了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平 台。通过依赖注入机制，我们只需要通过 简单的配置，而无需任何代码就可指定目标 需 要的资源，完成自身的业务逻辑，而不需要关心具体的资 源来自何处，由谁实现。 IoC是一个概念，是一种思想，其实现方式多种多样。依赖注入就是其中用的比较多的一 种方式。
2）Ioc和DI是同一个概念的不同角度描述。IoC是一种思想，概念，DI是实现它的手段。Spring框 架使用依赖注入实现IoC. Spring 容器是一个超级大工厂，负责创建、管理所有的 Java 对象， 这些 Java 对象被称为 Bean。 Spring 容器管理着容器中 Bean 之间的依赖关系，Spring 使 用 “依赖注入”的方式来管理 Bean 之间的依赖关系。使用 IoC 实现对象之间的解耦和。
3）注入：bean 实例在调用无参构造器创建对象后，就要对 bean 对象的属性进行初始化。初始化 是由容器自动完成的，称为注入。
4）注入的分类：
通过一个简单的案例来说明：现在有一个dao,还有一个servce，在servce里面，我们要使用到dao，这个时候我们采用Spring的方式来实现它。
1）通过set方法
dao层：
public class TeamDao {
public void add(){
System.out.println("TeamDao------add-----------");
}
}service层：
我们需要在service层中创建一个setDao的方法。
import com.zj.dao.TeamDao;
public class TeamServlet {
private TeamDao teamDao;
public void add(){
teamDao.add();
}
public void setTeamDao(TeamDao dao){
this.teamDao = dao;
}
}
在配置文件中依赖注入：
<bean id="testDao" class="com.zj.dao.TeamDao"></bean>
<bean id="testServlet" class="com.zj.servlet.TeamServlet">
<!--使用set方法注入属性值-->
<property name="teamDao" ref="testDao"></property>
</bean>编写测试：
@Test
public void test01(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("DI.xml");
TeamServlet testServlet = (TeamServlet) applicationContext.getBean("testServlet");
testServlet.add();
}2）通过构造方法注入
在servce层中，添加他的带参构造方法：
import com.zj.dao.TeamDao;
public class TeamServlet {
private TeamDao teamDao;
public void add(){
teamDao.add();
}
public TeamServlet() {
}
public TeamServlet(TeamDao teamDao) {
this.teamDao = teamDao;
}
}在配置文件中加入：（此处的name属性就是我们service中的变量值）
<bean id="testDao" class="com.zj.dao.TeamDao"></bean>
<!--使用构造方法注入属性值-->
<bean id="testServlet2" class="com.zj.servlet.TeamServlet">
<property name="teamDao" ref="testDao"></property>
</bean>测试类：
@Test
public void test01(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("DI.xml");
TeamServlet testServlet = (TeamServlet) applicationContext.getBean("testServlet");
testServlet.add();
TeamServlet testServlet2 = (TeamServlet) applicationContext.getBean("testServlet2");
testServlet2.add();
}3）自动注入：（两种形式）
配置文件：
<bean id="testDao" class="com.zj.dao.TeamDao"></bean>
<bean id="testServlet3" class="com.zj.servlet.TeamServlet" autowire="byName" >
<!--使用自动注入的方式-->
</bean>过程描述：当加入autowire=“byName”这个属性之后，系统监测到class这个属性里面的值，就会去里面找到这个类的成员变量testDao，他会和id=“testDao”进行匹配，匹配成功后，我们可以直接将她注入到我们的当前这个对象中。
对于autowire="byType"来说，是比较类型，当有两个相同类型的对象在xml文件中被创建，就会直接报错，这个就存在很大的弊端。
11、Spring核心-IoC-基于注解实现IoC
用一个小小的案例来说明吧！
dao类
import org.springframework.stereotype.Component;
//在类上添加注解@Component表示该类创建对象的权限交给Spring容器。注解的value属性用于指定bean的id值，value可以省略。
//@Component 不指定 value 属性，bean 的 id 是类名的首字母小写。
@Component
public class TeamDao {
public void add(){
System.out.println("TeamDao------add-----------");
}
public TeamDao(){
System.out.println("TeamDao----------默认的构造方法执行了------------");
}
}写一个annotation.xml的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
">
<!--表示告知Spring要扫描的包
这些包或者子包当中的类使用了Component注解，都交给Spring来创建类的对象
-->
<context:component-scan base-package="com.zj.dao"></context:component-scan>
</beans>写测试类：
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test03 {
@Test
public void test01(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("annotation.xml");
}
}
12、 Spring核心-IoC-属性注入的注解实现
1）对于自定义的类如何赋值：
实体类：采用value值的形式复制，有两种形式，可以直接用到setter上
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
* 球队的实体类
*/
@Component
public class Team {
@Value("001")
private Integer id;
@Value("蒲公英队")
private String name;
@Value("成都信息工程大学")
private String location;
public Team(Integer id, String name, String location) {
this.id = id;
this.name = name;
this.location = location;
System.out.println("Team-----------全参构造方法"+id+","+name+","+location);
}
public Team() {
System.out.println("Team-----------默认的构造方法");
}
public void init() {
System.out.println("Team ---- init()");
}
public void destroy() {
System.out.println("Team ---- destroy()");
}
@Override
public String toString() {
return "Team{" +
"id=" + id +
", name='" + name + '\'' +
", location='" + location + '\'' +
'}';
}
}
@Value("1")
public void setId(Integer id) {
this.id = id;
}
配置文件：你要配置他的包名
<context:component-scan base-package="com.zj.bean"></context:component-scan>
测试类：
import com.zj.bean.Team;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test04 {
@Test
public void test01(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("annotation.xml");
Team team = (Team) applicationContext.getBean("team");
System.out.println(team);
}
}2）对于引用类型：
方法一：添加注解@Autowired，实现自动装配（可以放在属性上，也可以放在setter方法上）
当required=false时，如果没有扫描到teamDao的话，将他置为Null，会报空指针异常。如果为true,并且没有扫描到的话，直接报错。
方法二：使用jdk中的@resource注解
也可以自己去指定名字和类型
13、 Spring核心-IoC-总结
loC 的思想就是让 Spring 容器去给我们创建对象。有两个方法，第一个是使用 bean 标签，第二个是使用注解的形式。这让对象创建的权限从程序员到Spring的权力的转移，我们是通过DI（依赖注入）来实现的。
520
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
