Spring框架是一种非侵入式设计的框架，主要用于解决对象创建和依赖关系处理。它支持控制反转（IOC）、依赖注入（DI），以及面向切面编程（AOP）。Spring提供了包括核心功能、Web模块、DAO支持、ORM整合、AOP编程和Java EE模块的一站式解决方案。
spring框架
专业术语了解
组件/框架设计：
侵入式设计
引入了框架，对现有的类的结构有影响；即需要实现或继承某些特定类。
例如： Struts框架
非侵入式设计
引入了框架，对现有的类结构没有影响。
例如：Hibernate框架 / Spring框架
控制反转:
Inversion on Control , 控制反转 IOC
对象的创建交给外部容器完成，这个就做控制反转.
依赖注入
dependency injection 处理对象的依赖关系
区别：
控制反转， 解决对象创建的问题 【对象创建交给别人】
依赖注入，
在创建完对象后， 对象的关系的处理就是依赖注入 【通过set方法依赖注入】
AOP
面向切面编程。切面，简单来说来可以理解为一个类，由很多重复代码形成的类。
切面举例：事务、日志、权限;
概述
Spring框架，可以解决对象创建以及对象之间依赖关系的一种框架。
且可以和其他框架一起使用；Spring与Struts, Spring与hibernate
(起到整合（粘合）作用的一个框架)
Spring提供了一站式解决方案：
1） Spring Core spring的核心功能： IOC容器, 解决对象创建及依赖关系
2） Spring Web Spring对web模块的支持。
- 可以与struts整合,让struts的action创建交给spring
- spring mvc模式
3） Spring DAO Spring 对jdbc操作的支持 【JdbcTemplate模板工具类】
4） Spring ORM spring对orm的支持：
既可以与hibernate整合，【session】
也可以使用spring的对hibernate操作的封装
5）Spring AOP 切面编程
6）SpringEE spring 对javaEE其他模块的支持
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
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">
</beans>
API
细节
/**
* 1) 对象创建： 单例/多例
* scope="singleton", 默认值， 即 默认是单例 【service/dao/工具类】
* scope="prototype", 多例； 【Action对象】
*
* 2) 什么时候创建?
* scope="prototype" 在用到对象的时候，才创建对象。
* scope="singleton" 在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。
* 3)是否延迟创建
* lazy-init="false" 默认为false, 不延迟创建，即在启动时候就创建对象
* lazy-init="true" 延迟初始化， 在用到对象的时候才创建对象
* （只对单例有效）
* 4) 创建对象之后，初始化/销毁
* init-method="init_user" 【对应对象的init_user方法，在对象创建爱之后执行 】
* destroy-method="destroy_user" 【在调用容器对象的destriy方法时候执行，(容器用实现类)】
*/
@Test
public void testIOC() throws Exception {
// 得到IOC容器对象 【用实现类，因为要调用销毁的方法】
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
// 从容器中获取bean
User user1 = (User) ac.getBean("user");
User user2 = (User) ac.getBean("user");
System.out.println(user1);
System.out.println(user2);
// 销毁容器对象
ac.destroy();
}
配置文件：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"
xmlns:p="http://www.springframework.org/schema/p"
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">
<!-- ###############对象创建############### -->
<!-- 1. 默认无参数构造器
<bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
-->
<!-- 2. 带参数构造器 -->
<bean id="user2" class="cn.itcast.b_create_obj.User">
<constructor-arg index="0" type="int" value="100"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
</bean>
<!-- 定义一个字符串，值是"Jack" ; String s = new String("jack")-->
<bean id="str" class="java.lang.String">
<constructor-arg value="Jacks"></constructor-arg>
</bean>
<bean id="user3" class="cn.itcast.b_create_obj.User">
<constructor-arg index="0" type="int" value="100"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
</bean>
<!-- 3. 工厂类创建对象 -->
<!-- # 3.1 工厂类，实例方法 -->
<!-- 先创建工厂 -->
<bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
<!-- 在创建user对象，用factory方的实例方法 -->
<bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
<!-- # 3.2 工厂类： 静态方法 -->
<!--
class 指定的就是工厂类型
factory-method 一定是工厂里面的“静态方法”
-->
<bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>
</beans>
public class App {
// 1. 通过工厂类得到IOC容器创建的对象
@Test
public void testIOC() throws Exception {
// 创建对象
// User user = new User();
// 现在，把对象的创建交给spring的IOC容器
Resource resource = new ClassPathResource("applicationContext.xml");
// 创建容器对象(Bean的工厂), IOC容器 = 工厂类 + applicationContext.xml
BeanFactory factory = new XmlBeanFactory(resource);
// 得到容器创建的对象
User user = (User) factory.getBean("user");
System.out.println(user.getId());
}
//2. （方便）直接得到IOC容器对象
@Test
public void testAc() throws Exception {
// 得到IOC容器对象
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
// 从容器中获取bean
User user = (User) ac.getBean("user");
System.out.println(user);
}
}
实例
实例1：依赖注入
实体类：User.java
public class User {
private String name;
private int age;
private String sex；
......（省略Setter()与Getter()方法）
配置文件：applicationContext.xml
<!-- bean标签定义JavaBean的名称和类型 -->
<bean id="user" class="spring.User">
<property name="name">
<value>小强</value>
</property>
<property name="age">
<value>18</value>
</property>
<property name="sex">
<value>男</value>
</property>
</bean>
实现类：APP.java
public static void main(String[] args) throws Exception{
/*
* 使用BeanFactory管理bean,通过从XML配置文件或属性文件（properties）中
* 读取javaBean的定义，来实现javaBean的创建，配置，管理
* 装载配置文件的3个实现类
* 1.当前路径 ApplicationContext ac = new ClassPathXmlApplicationContext(String Controller);
* 2.不止当前路径 ApplicationContext ac = new FileSystemXmlApplicationContext(String Controller);
* 3.在Servlet的web.xml文件中配置Spring的ContextLoaderListener监听器
* 或修改web.xml配置文件中添加一个Servlet，定义使用Spring的org.springframework.web.context.ContextLoaderServlet类
*/
//装载配置文件
Resource resource = new ClassPathResource("spring/applicationContext.xml");
BeanFactory factory = new XmlBeanFactory(resource);
//获取bean
User user = (User)factory.getBean("user");
System.out.println("姓名：" + user.getName());
System.out.println("年龄：" + user.getAge());
System.out.println("性别：" + user.getSex());
}
实例2：构造器注入
User.java
//构造器注入 它的构造方法被调用并且只能调用一次，所以构造器常被用于类的初始化操作
public User(String name,Integer age,String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public void printInfo() {
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
System.out.println("性别：" + sex);
}
applicationContext.xml
<bean id="user" class="spring.User">
//可以为构造方法传参
<constructor-arg>
<value>小强</value>
</constructor-arg>
<constructor-arg>
<value>18</value>
</constructor-arg>
<constructor-arg>
<value>男</value>
</constructor-arg>
</bean>
APP.java
Resource resource = new ClassPathResource("spring/applicationContext.xml");
BeanFactory factory = new XmlBeanFactory(resource);
User user = (User)factory.getBean("user");
user.printInfo();
实例3：引入其他的bean
applicationContext.xml
<bean name="/main.do" class="spring.Manger">
<property name="user">
<ref local="user"/>
</property>
</bean>
web.xml
<servlet>
<servlet-name>DispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
通知DispatcherServlet去指定的目录下加载applicationContext.xml配置文件
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:/WEB-INF/applicationContext.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>DispatcherServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<servlet>
App.java
public class App extends AbstractControController{
private User user;
public User getUser(){
return user;
}
public User setUser(){
this.user = user;
}
protected ModelAndView handleRequestInternal(HttpServletRequest arg0, HttpServletResponse arg1) throws Exception {
// TODO Auto-generated method stub
user.printInfo();
return null;
}
}
实例4：自动装配
PrintInfo.java
package spring;
/*
* 自动装配
* <bean>元素的byname属性以属性名或类型区分自动装配。
* 在容器中寻找与javabean的属性名相同的Javabean,
* 并将其自动装配到javabean中
* */
public class PrintInfo {
private User user;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public void PrintUser() {
System.out.println("姓名：" + user.getName());
System.out.println("年龄：" + user.getAge());
System.out.println("性别：" + user.getSex());
}
}
APP.java
Resource resource = new ClassPathResource("spring/applicationContext.xml");
BeanFactory factory = new XmlBeanFactory(resource);
//获取bean
PrintInfo printInfo = (PrintInfo)factory.getBean("printInfo");
printInfo.PrintUser();
//名称装配
<bean autowire="byName" id="printInfo" class="spring.PrintInfo"></bean>
//类型装配
<bean autowire="byType" id="printInfo" class="spring.PrintInfo"></bean>
扫一扫
720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
