spring框架

web网页：js、jquery
服务器：
web层：struts、springMVC
service层：spring
dao层：hibernate、mybatis

Spring：开源框架、轻量级
Spring核心：IOC(控制反转：将创建对象的控制权反转给Spring)、DI(依赖注入)、AOP(切面编程)
Spring优点：

1. 方便解耦，简化开发(高内聚低耦合)
2. AOP编程的支持
3. 声明事务的支持
4. 方便程序的测试
5. 方便集成各种优秀的框架
6. 降低JavaEE API的使用难度

Core Container(核心容器)：Beans(管理bean)、Core(核心)、Context(上下文ＩＯＣ，大部分为配置文件)、Expression Language(spEL语句)

IOC：
导入jar包：
4+1：4个核心(beans、core、context、expression)，1个依赖(commons-logins…jar)

IoC使用标签，DI使用标签

IOC目标类：

提供UserService接口和实现类，获得UserService实现类的实例，不用Spring需new对象
使用Spring，将由Spring创建实例---IOC(控制反转Inverse of Control)，之后需要实例对象时，从Spring容器获得，需要将实现类的全限定名称配置到xml文件中

IOC配置文件：

位置：开发中一般在classpath(src)
名称：开发中一般用applicationContext.xml
内容：添加schema约束

<?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
        										https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--配置service文件
			bean：配置需要创建的对象
					id：用于在Spring容器中获得实例
					class：需要创建实例的全限定类名
	-->
    <bean id="userServiceId" class="com.zz.ioc.UserServiceImpl">   
    </bean>
</beans>


@Test
public void demo02(){
	//从Spring容器中获得
	//1、获得容器，即获得xml文件
	String xmlPath=“com/zz/ioc/beans.xml”;
	ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
	//2、获得内容
		//这里使用了反射，首先通过applicationContext对象获得bean.xml文件，然后解析此文件的内容，然后通过key-value获得需要get的bean，这时得到的只是对象的字符串形式，并无实际意义，最后通过反射获得此类，通过newInstance()方法获得bean中的相应的对象
	UserService userService=(UserService)applicationContext.getBean("userServiceId");
	userSerivce.addUser();
}

DI:

DI:dependency Injection:依赖注入
is a：是一个，继承
has a：有一个，成员变量，依赖
class B{
private A a; //B类依赖于A类
}
依赖：一个对象需要使用到另外一个类中的对象
注入：通过setter方法进行另一个对象实例的设置，即通过setter方法对A类中的a进行设置

class BookServiceImpl{
//之前开发，接口=实现类(Service和Dao耦合)
private BookDao bookDao =new BookDaoImpl();
//Spring之后(解耦，Service实现类使用dao接口，不知道具体的实现类)
private BookDao bookDao;
setter方法
}

目标类

创建bookService接口和实现类
创建bookDao接口和实现类
将dao和service配置到xml文件
使用api测试

dao

BookDao:
class interface BookDao{
	void addBook();
}

BookDaoImpl:
class BookDao implement BookDaoImpl{
	@Override
	public void addBook(){
		sout("add book");
	} 
}

service

BookService:
class interface BookService{
	void addBook();
}

BookServiceImpl:
class BookServiceImpl{
	private BookDao bookDao;
	public void setBook(BookDao bookDao){
		this.bookDao=bookDao;
	}
	
	@Override
	public void addBook(){
		bookDao.addBook();
	}
}

配置文件

<?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
        										https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--配置service文件
			bean：配置需要创建的对象
					id：用于在Spring容器中获得实例
					class：需要创建实例的全限定类名
						<property>进行属性的注入
									name：bean的属性通过setter方法来获得-->BookDao-->bookDao
									ref：另一个bean的id引用-->bookServiceId
	-->
	<!--创建Serivce-->
    <bean id="bookServiceId" class="com.zz.Service.Impl.BookServiceImpl">   
    	<property name="bookDao" ref="bookDaoId">
    	</property>
    </bean>
    <!--创建Dao-->
    <bean id="bookDaoId" class="com.zz.Dao.Impl.BookDaoImpl">
    <bean>
</beans>

test:
@Test
public void demo01(){
	//从Spring容器中获得
	//1、获得容器，获取xml文件
	String xmlPath="com/zz/Service/Impl/BookServiceImpl";
	ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
	//2、获取内容，解析xml文件，获取xml文件内容，通过反射，创建对象
	BookService bookService=(BookService)applicationContext.getBean("bookServiceId"); 
	bookService.addBook();
}

核心API

BeanFactory:这是一个工厂，用于生产任意bean
ApplicationContext:是BeanFactory的子接口，功能更强大
ClassPathXmlApplicationContext:用于加载classpath(类路径、src)下的指定的xml
FileSystemXmlApplicationContext:用于加载指定盘符下的xml(通过ServletContext.getRealPath()获得具体盘符)

装配Bean 基于XML

实例化方式
3种bean实例化方式：默认构造、静态工厂、实例工厂
默认构造
必须提供默认构造
静态工厂
常用于Spring整合其他框架(工具)
用于生产实例对象，所有的方法必须是静态的

不用使用Spring的静态工厂

MyBeanFactory(静态工厂):
public class MyBeanFactory{
	public static UserService createUserService(){
		renurn new UserServiceImpl();
	}
}

UserService:
public interface UserService{
	public  void addUser();
}

public class UserServiceImpl implement UserService{
	@Override
	public void addUser(){
		sout("add user");
	}
}

Test:
public class test{
	@Test
	public void test(){
		//通过静态工厂创建UserServiceImpl对象
		UserService userService=MyBeanFactory.createUserService();
		userService.addUser();
	}
}



使用Spring的静态工厂
配置bean
<?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
        										https://www.springframework.org/schema/beans/spring-beans.xsd">
	<!--将静态工厂创建的实例交予Spring
			id:要创建的对象的名称
			class:静态工厂的全限定类名
			factory-method:确定对应的静态方法-->
	<bean id="userServiceId" class="com.zz.static_factory.MyBeanFactory" factory-method="createService">
	</bean>

</beans>

Test:
@Test
public void test(){
	//获取容器，即获取文件
	String xmlPath="com/zz/static_factory/beans.xml";
	ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
	//获取内容
	UserService userService=applicationContext.getBean("userServiceId",UserService.class);
	userService.addUser();
}

实例工厂

必须先有工厂实例对象，通过实例对象创建对象，提供所有的方法都是非静态的

//不使用Spring创建Service对象
@Test
public void test(){
	//实例工厂需要创建工厂对象，从而调用工厂中的方法
	MyBeanFactory myBeanFactory=new MyBeanFactory();
	UserService userService=myBeanFactory.createUserService();
	userService.addUser();
}


//使用Spring创建Service对象
<?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
        										https://www.springframework.org/schema/beans/spring-beans.xsd">
	<!--将实例工厂创建的实例交予Spring
			id:要创建的对象的名称
			class:实例工厂的全限定类名-->
	<bean id="myBeanFactoryId" class="com.zz.instance_factory.MyBeanFactory">
	</bean>
	<!--获得UserService
			factory-bean:确定工厂实例
			factory-method:确定普通方法-->
	<bean id="userServiceId" factory-bean="myBeanFactoryId" factory-method="createService">
	</bean>
</beans>

@Test
public void test(){
	//获取文件
	String xmlPath="com/zz/instance_factory/beans.xml";
	ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
	//获取内容
	UserService userService=application.getBean("userServiceId",UserService.class);
}

bean的种类

普通bean： Spring直接创建类的实例，并返回
FactoryBean：是一个特殊的bean，具有工厂生成对象能力，只能生成特定的对象
bean必须使用FactoryBean接口，此接口提供方法getObject()用于获得特定bean

BeanFactory和FactoryBean对比：
BeanFactory：工厂，用于生成任意bean
FactoryBean：特殊Bean，用于生成特定Bean， 获得代理对象实例

作用域(scope)

作用域：用于确定Spring创建bean实例个数
singleton：单例
prototype：多例

属性依赖注入
构造方法
setter方法