初识Spring框架及使用

初识Spring框架及使用

1.什么是spring框架？
spring是一个分层解决业务逻辑与其他各层之间松耦合问题的JavaEE/JavaSE一站式开源框架。
松耦合：降低类与类之间的联系
高内聚：实现某一功能的程序集中在一起
好处：不用牵一发动全身，那里有错修改那里
目的：为了提高代码的重用性，便于维护
2.spring的构成？

上面是Spring官方提供的结构图
从下往上test[测试]，core容器，aop[面向切面编程]，web，data access
1.test部分只有一个模块：
spring-test.jar：spring测试，提供junit与mock测试功能.

2.core容器包含4个模块
spring-core：依赖注入IoC与DI的最基本实现
spring-beans：Bean工厂与bean的装配
spring-context：spring的context上下文即IoC容器
spring-expression：spring表达式语言

3.aop[面向切面]部分包含4个模块
spring-aop：面向切面编程
spring-aspects：集成AspectJ
spring-instrument：提供一些类级的工具支持和ClassLoader级的实现，用于服务器spring-instrument-tomcat：针对tomcat的instrument实现

4.web部分包含4个模块
spring-web：基础web功能，如文件上传
spring-webmvc：mvc实现
spring-webmvc-portlet：基于portlet的mvc实现
spring-struts：与struts的集成，不推荐，spring4不再提供

5.data access部分包含5个模块
spring-jdbc：jdbc的支持
spring-tx：事务控制
spring-orm：对象关系映射，集成orm框架
spring-oxm：对象xml映射
spring-jms：java消息服务

3.Spring的优点
3.1 方便解耦，简化开发：Spring是一个超级工厂（超级容器），可以将对象的创建和依赖关系交给Spring工厂去管理
3.2 AOP编程：Spring提供面向切面编程，可以方便的对程序进行运行监控、权限验证等操作
3.3 声明事务：只需要通过配置就可以完成对事务的管理，不需要手动编程
3.4 方便测试：Spring支持junit4，可以通过Spring注解方式测试程序
3.5 方便集成各种框架：Spring支持各种开源框架的集成。例如（struts、Hibernate、MyBaties等）
3.6 降低JavaEE API的使用难度：Spring对JavaEE开发中非常难用的API进行封装，使这些开发API应用难度降低

4.Spring的核心技术
4.1 IOC（Inverse of Control 反转控制）：将java对象创建和维护权利交由Spring工厂进行管理和维护。
4.2 DI(依赖注入)：将某一个java类中的依赖对象快速的添加到另一个java类中。
4.3 AOP（Aspect Oriented Programming 面向切面编程），基于动态代理的功能增强方式 [ 给自己的程序中添加一些系统需求的处理 (日志管理，数据的安全性检查…) ]。
4.4 事务管理的相关操作。
4.5 spring整合/管理其他各层的框架 (Spring集成Web层SpringMVC/Spring整合数据访问层MyBatis)

5.Spring的IOC（Inverse of Control 反转控制）
5.1 没有使用IOC时

public  class  Student{
public  void  getStuInfo(){
System.out.println(“Student类的实例方法”)；
	}
}

public class  TestMain{
  public static  void  main(String  args){
      Student  stu=new Student();
      stu.getStuInfo();
	}
}

上面程序需要自己手动创建对象

5.2 使用IOC时
导入 spring-context 依赖：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.5.RELEASE</version>
</dependency>

创建Student 类：

package qing.bean;
public class Student {
    public void getInfo(){
        System.out.println("Student的实例方法-----");
    }
}

配置文件 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="stu" class="qing.bean.Student"></bean>
</beans>

测试类：

package qing.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import qing.bean.Student;
public class TestMain {
    public static void main(String[] args) {
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
        Student student=(Student) ac.getBean("stud");
        student.getInfo();
    }
}

上面是spring创建的对象
总结：IOC就是将对象创建和维护的权利从开发者手中转移到spring

5.3 spring配置文件：
名称:推荐使用applicationcontext.xml
位置:一般都在resources目录中
内容:

<?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 -->
        <!-- 通知Sping容器创建类对象 -->
        <!--class属性：指定创建对象的java类【包名+类名】-->
        <!--id属性:指定对象名称-->
        <bean id="stu" class="com.wangxing.spring.bean.Student"></bean>
</beans>

配置文件内容解析：

<?xml version="1.0" encoding="UTF-8"?> ---表示一个xml文件

----Spring配置文件的根元素
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
-----根元素中引入的其他元素的命名空间以及地址，约束文件
----通知Sping容器创建类对象
class属性: 指定创建对象的java类 (包名+类名)
id属性: 指定对象名称，将来从Spring容器中得到自己需要的对象是要依赖这个属性值。

5.4 Spting容器对象
Spting容器对象 —用来保存和维护Spting创建的对象。
Spting容器对象

ApplicationContext接口是BeanFactory接口的子接口
创建ApplicationContext接口对象/BeanFactory接口对象
new ClassPathXmlApplicationContext(“Spring配置文件”)----通过查找classpath[类路径{resources目录}]下的Spring配置文件创建ApplicationContext接口对象/BeanFactory接口对象。
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
BeanFactory ac=new ClassPathXmlApplicationContext("applicationcontext.xml");

new FileSystemXmlApplicationContext("Spring配置文件");---通过查找系统路径[理解成绝对路径]下的Spring配置文件创建ApplicationContext接口对象/BeanFactory接口对象。(不推荐使用)
ApplicationContext ac=new FileSystemXmlApplicationContext("D:\\SpringDemo1\\src\\main\\resources\\applicationcontext.xml");
BeanFactory ac=new FileSystemXmlApplicationContext("D:\\SpringDemo1\\src\\main\\resources\\applicationcontext.xml");

6. Bean实例化的4种方式：
6.1 无参构造方法
Student类：

package qing.bean;
public class Student {
    public void getInfo() {
        System.out.println("Student的实例方法-----");
    }
}

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="stu" class="qing.bean.Student"></bean>
</beans>

6.2 静态工厂方法：
Student类：

package qing.bean;
public class Student {
    public void getInfo() {
        System.out.println("Student的实例方法-----");
    }
}

静态工厂类 StaticFactoryStudent ：

package qing.bean;
public class StaticFactoryStudent {
    public static Student getStuInfo() {
        return new Student();
    }
}

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="student" class="qing.bean.StaticFactoryStudent" factory-method="getStuInfo" ></bean>-->
</beans>

6.3 实例工厂方法：
Student类：

package qing.bean;
public class Student {
    public void getInfo() {
        System.out.println("Student的实例方法-----");
    }
}

实例工厂类 FactoryStudent ：

package qing.bean;
public class FactoryStudent {
    public Student getStuInfo() {
        return new Student();
    }
}

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="FactoryStudent" class="qing.bean.FactoryStudent"></bean>-->
    <!--<bean id="stu" factory-bean="FactoryStudent" factory-method="getStuInfo"></bean>-->
</beans>

6.4 FactoryBean接口方式实例化bean
Student类：

package qing.bean;
public class Student {
    public void getInfo() {
        System.out.println("Student的实例方法-----");
    }
}

FactoryBeanStudent类实现FactoryBean 接口重写方法 ：

package qing.bean;
import org.springframework.beans.factory.FactoryBean;
public class FactoryBeanStudent implements FactoryBean {
    @Override
    public Object getObject() throws Exception {
        return new Student();
    }

    @Override
    public Class<?> getObjectType() {
        return Student.class;
    }
}

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">
   	<!-- 实现FactoryBean接口方法 -->
    <bean id="stud" class="qing.bean.FactoryBeanStudent"></bean>
</beans>

7. FactoryBean接口与BeanFactory接口的区别
BeanFactory接口是Spting容器用来保存和维护Spting创建的对象 (管理)
FactoryBean接口是用来创建java对象 (创建)