Spring框架（1）— 基本架构、bean

Spring框架

一、spring概念

Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。

Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。

Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。因此， Spring不仅仅能应用于JEE应用程序之中，也可以应用于桌面应用程序以及小应用程序之中。

二、spring框架的基本架构

Spring的helloworld

spring开发流程：
1.引入框架
2.配置spring容器 （对象属性blabla）
3.通过工厂取出对象 （bean 的id）

1.创建maven项目

2.引入spring框架

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0modelVersion>
	<groupId>com.dyit.springgroupId>
	<artifactId>spring-helloartifactId>
	<version>0.0.1-SNAPSHOTversion>

	<dependencies>
		<dependency>
			<groupId>org.springframeworkgroupId>
			<artifactId>spring-contextartifactId>
			<version>5.3.15version>
		dependency>
	dependencies>
project>

3. 定义一个类

Car.java

package com.dyit.spring;

public class Car {

	private Integer id;
	private String brand;
	private String color;
	private Double price;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getBrand() {
		return brand;
	}

	public void setBrand(String brand) {
		this.brand = brand;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public Double getPrice() {
		return price;
	}

	public void setPrice(Double price) {
		this.price = price;
	}

	@Override
	public String toString() {
		return "Car [id=" + id + ", brand=" + brand + ", color=" + color + ", price=" + price + "]";
	}

}

4.配置spring容器

applicationContext.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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	 http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="bwmx" class="com.dyit.spring.Car">
		<property name="id" value="1"/>
		<property name="brand" value="奔驰"/>
		<property name="color" value="黄色"/>
		<property name="price" value="800000.00"/>
		
	</bean>

</beans>

5.实现

//获取容器
@test
public void springTest(){

		ApplicationContext  act =
				new FileSystemXmlApplicationContext("classpath:spring/applicationContext.xml");//工厂  必须写classpath 表示根目录 
		
		Car bean = act.getBean(Car.class, "bwmx"); //取出对象  getBean(类型 ，容器中的bean的id）
		
		System.out.println(bean);
}

三、spring的容器(bean)配置文件

Spring bean的加载流程

Bean配置信息定义了Bean的实现及依赖关系，Spring容器根据各种形式的Bean配置信息在容器内部建立Bean定义注册表，然后根据注册表加载、实例化Bean，并建立Bean和Bean的依赖关系，最后将这些准备就绪的Bean放到Bean缓存池中，以供外层的应用程序进行调用。

配置bean——启动容器——读取配置信息，生成注册表——根据注册表实例化car对象——把实例化后的bean放入容器工厂的缓存池中——getBean（）方法从缓存中读取到car对象

1.配置bean

	<bean id="bwmx" class="com.dyit.spring.Car">
		<property name="id" value="1"/>
		<property name="brand" value="奔驰"/>
		<property name="color" value="黄色"/>
		<property name="price" value="800000.00"/>
		
	bean>

2.容器启动(加载工厂)

//获取容器
ApplicationContext  act =
				new FileSystemXmlApplicationContext("classpath:spring/applicationContext.xml");	

3. 读取配置信息

在容器中定义了一个bean的注册表: 将Bean的信息注册到容器中

4.根据注册表实例化Bean的对象

5.放入容器（工厂）的缓存中

6.从缓存中读取

	Car bean = act.getBean(Car.class, "bwmx");//从缓存中读取

bean的配置

1.bean对象默认是单例的

（底层用的是localthread 线程本地化）

2.bean标签解析

    <bean id="bwmx" class="com.dyit.spring.Car" init-method="ininx">
		<property name="id" value="1"/>
		<property name="brand" value="奔驰"/>
		<property name="color" value="黄色"/>
		<property name="price" value="800000.00"/>	
	</bean>

• id/name : 在容器（注册表）中的唯一名称(不能重复)

• class : 类的全名- 包名.类名

• init-method: 在对象创建之后，第一个调用的方法.

public class Car {

	private Integer id;
	private String brand;
	private String color;
	private Double price;

   public void initx(){
   System.out.println("initx")
   }
  //部分代码

<bean id="bwmx" class="com.dyit.spring.Car" init-method="initx">

执行结果：

• destroy-method: 在容器销毁对象时调用的方法

  <bean id="bwmx" class="com.dyit.spring.Car" init-method="initx" destroy-method="finish"> 
  

• ref：依赖关系。引用容器中的bean的id/name。tom的车引用了bwmx

  public class Person {
  
  	private String name;
  	private Car car;
  
  

  	<bean id="bwmx" class="com.dyit.spring.Car" init-method="initx" destroy-method="finish" > 
  		<property name="id" value="1"/>
  		<property name="brand" value="奔驰"/>
  		<property name="color" value="黄色"/>
  		<property name="price" value="800000.00"/>
  	bean>
  	
  	<bean id="tom" class="com.dyit.spring.Person">
  		<property name="name"  value="关羽"/>
  		<property name="car" ref="bwmx"/>
  	bean>
  

3.Demo：bean配置

需求：有三个类，配置出三者的依赖关系。
公司类Company（name, emp） -->员工Emp(name, book) -->Book(title, author,price)

• 假设一名员工有多本书，如何修改？
  private List books

<property name="books">
			<list>
				<ref bean="bookx"/>
				<ref bean="bookx"/>
				<ref bean="bookx"/>
				<ref bean="bookx"/>
			</list>
		</property>

• 假设一个公司有多名员工？
  private Map map

<property name="map" >
			<map>
				<entry key="张三" value-ref="empx"/>
				<entry key="李四" value-ref="empx"/>
				<entry key="王五" value-ref="empx"/>
			</map>	
		</property>

Book.java

public class Book {

	private String title;
	private String author;
	private double price;

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getAuthor() {
		return author;
	}

	public void setAuthor(String author) {
		this.author = author;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	@Override
	public String toString() {
		return "Book [title=" + title + ", author=" + author + ", price=" + price + "]";
	}
	
}

Emp.java

public class Emp {

	private String name;
	private List<Book> books;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public List<Book> getBooks() {
		return books;
	}
	public void setBooks(List<Book> books) {
		this.books = books;
	}
	@Override
	public String toString() {
		return "Emp [name=" + name + ", books=" + books + "]";
	}
}

Company.java

public class Company {

	private String name;
	private Map<String, Emp> map;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Map<String, Emp> getMap() {
		return map;
	}

	public void setMap(Map<String, Emp> map) {
		this.map = map;
	}

	@Override
	public String toString() {
		return "Company [name=" + name + ", map=" + map + "]";
	}

}

三者配置文件。applicationContext.xml

	<bean id="bookx" class="com.dyit.spring.Book">
		<property name="title" value="三国演义"/>
		<property name="author" value="罗贯中"/>
		<property name="price" value="35.00"/>
	bean>
	
	<bean id="empx" class="com.dyit.spring.Emp">
		<property name="name" value="张三"/>
		<property name="books">
			<list>
				<ref bean="bookx"/>
				<ref bean="bookx"/>
				<ref bean="bookx"/>
				<ref bean="bookx"/>
			list>
		property>
	bean>
	
	<bean id="comx" class="com.dyit.spring.Company">
		<property name="name" value="dyit"/>
		<property name="map" >
			<map>
				<entry key="张三" value-ref="empx"/>
				<entry key="李四" value-ref="empx"/>
				<entry key="王五" value-ref="empx"/>
			map>	
		property>
	bean>

测试代码：

@test
public void testComp(){

		ApplicationContext  act =new FileSystemXmlApplicationContext("classpath:spring/applicationContext.xml");//工厂  //必须写classpath 表示根目录 		
		Company bean = act.getBean(Company.class, "comx"); //取出对象  getBean(类型 ，容器中的bean的id）
	    Map<String,Emp> map =bean.getMap();	
	    for(Entry<String,Emp> e:map.entrySet()){
	          System.out.println(e.getKey()+"-"+e.getValue());
}
		

测试结果：

4.使用注解配置，

使用注解创建对象，四个注释没有本质差别，只有被用来区分用在不同的层

@Controller ——用在控制层

@Service——用在服务层、前后端交互层

@Repository——用在数据库操作层

@Component --组件

能被扫描到spring下所有类的对象

流程：

第一步： 扫描包下的类是否有@Controller, @Service @Repository @Component,将注解的类注册，实例化放入缓存

<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-4.3.xsd">

   //扫描的类 注意把namespaces的context勾选上
	<context:component-scan base-package="com.dyit.spring"/> 

beans>

第二步：@Service 注释类IBookSerivce（当前类再service包下）

public interface IBookService {
	
	void deleteBook(int id);

}

@Service
public class BookServiceImpl implements IBookService {

	@Override
	public void deleteBook(int id) {
		System.out.println("删除"+id+"成功");
		
	}
}

第三步：@controller 注解BookController类
@Autowired :自动查找容器中是否有IBookSerivce这种类型的对象，如果有则注入对象

@Controller
public class BookController {
    
    //@Autowired :自动查找容器中是否有IBookSerivce这种类型的对象，如果有则注入对象
	@Autowired
	private IBookService ibs; //ibs = new 。。。。
	
	public void del() {
	
		ibs.deleteBook(1);
	}

}

第四步 测试代码 bean调用del（）方法

	@Test
	public void testController() {
		ApplicationContext act = new FileSystemXmlApplicationContext("classpath:spring/applicationContext.xml");
		
		BookController bean = act.getBean(BookController.class);
		
		bean.del();
	}