Spring框架知识点（一）

最新推荐文章于 2023-08-22 09:09:46 发布

高风言

最新推荐文章于 2023-08-22 09:09:46 发布

阅读量470

点赞数 1

分类专栏： java框架文章标签： spring 框架 ioc aop 配置文件注入

本文链接：https://blog.csdn.net/gaofengyan/article/details/83305541

版权

java框架专栏收录该内容

18 篇文章 0 订阅

订阅专栏

Spring是一站式框架

1.spring在JavaEE三层结构中，每一层都提供不同的解决技术
Web 层：springMVC
Service 层：spring 的 ioc
Dao 层：spring 的 jdbcTemplate

Spring 概念

1. spring 是开源的轻量级框架
2. spring 核心主要两部分：
（1）Aop：面向切面编程，扩展功能不是修改源代码实现
（2）Ioc ：控制反转
— 比如有一个类，在类里面有方法（不是静态的方法），调用类里面的方法，创建类的对象，使用对象调用方法，创建类对象的过程，需要new出来对象。
— 把对象的创建不是通过new的方式实现，而是交给 spring 配置创建类对象

Ioc 底层原理

1. ioc底层原理使用技术
（1）xml配置文件
（2）dom4j解析xml
//根据配置文件的id值，得到id值对应的class属性值
String classValue = “class属性值”;
（3）工厂设计模式
（4）反射创建类的对象
反射的关键代码：
Class clazz = Class.forName(classValue); //使用发射创建类对象
UserService service = clazz.newInstance(); //创建类对象
如下图所示：
在这里插入图片描述

Spring的Bean 管理（xml方式）

Bean实例化的方式

1.在spring 里面通过配置文件创建对象
2.Bean实例化三种实现方式
第一种使用类的无参构造创建（重点）
在这里插入图片描述
类里面没有无参数的构造，会出现异常。
第二种使用静态工厂创建
（1）创建静态的方法，返回类对象

<!--使用静态方法创建对象  -->
<bean id="bean2" class="com.itcast.bean.Bean2Factory" factory-method="getBean2"></bean>

// 加载配置文件，根据创建对象
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       //得到配置创建的对象
		Bean2 bean2= (Bean2) context.getBean("bean2");
		System.out.println(bean2);

输出结果：com.itcast.bean.Bean2@2833cc44

第三种使用实例化工厂创建
（1）创建不是静态的方法，返回类的对象
Bean标签常用属性
（1）id 属性：起的名称，id属性值名称任意命名。
— Id属性值，不能包含特殊符号
— 根据id值得到配置对象
（2）class属性：创建对象所在类的全路径
（3）Name属性：功能和id属性一样的，id属性值不能包含特殊符号，但是name属性可以包含特殊字符。
（4）Scope属性：bean的作用范围
—singleton: 默认值，单例
在这里插入图片描述
—prototype: 多实例的对象

// 加载配置文件，根据创建对象
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 得到配置创建的对象
		User user = (User) context.getBean("user");
		User user1 = (User) context.getBean("user");
		System.out.println(user);
		System.out.println(user1);

结果：

com.itcast.ioc.User@5bc79255
com.itcast.ioc.User@47ef968d

— request: 创建对象把对象放到request
— session: 创建对象把对象放到session
— globalSession: 创建对象把对象放到globalSession（全局性的）—》登陆中

属性注入方式介绍

1.创建对象的时候，向类里面属性里面设置值
2.属性注入的方式（三种方式）
第一种使用set方法注入

Public class User{
  Private String name;
 Public void setName(String name){
   This.name = name;
  }
}
User user = new User();
User.setName(“abcd”);

第二种有参数构造注入

Public class User{
  Private String name;
 Public User(String name){
   This.name = name;
  }
}
User user = new User(“lucy”);

第三种使用接口注入

Public interface Dao{
  Public void delete(String name):
}
Public class DaoImpl implements Dao{
  Private String name;
 Public void delete(String name){
  This.name=name;
  }
}

3.在spring框架里面，支持前面两种方式
（1）set方法注入（重点）

public class Book {
	private String bookName;

	//set方法
	public void setBookName(String bookName) {
		this.bookName = bookName;
	}

	public void demobook() {
		System.out.println("book..........." + bookName);
	}
}

<!--使用set方法注入属性 -->
	<bean id="book" class="com.itcast.property.Book">
		<!-- 注入属性值   name属性值：类里面定义的属性名称 value属性值：设置具体的值 -->
		<property name="bookName" value="今天星期天"></property>
	</bean>

（2）有参数构造注入

public class PropertyDemo1 {
	private String userName;

	public PropertyDemo1(String userName) {
		this.userName = userName;
	}

	public void test1() {
		System.out.println("demo1............" + userName);
	}
}

<!--使用有参数构造注入属性 -->
	<bean id="demo" class="com.itcast.property.PropertyDemo1">
	 <!--使用有参数构造注入 -->
		<constructor-arg name="userName" value="小王小马"></constructor-arg>
	</bean>

注入对象类型属性（重点）

1.创建service类和dao类

package com.itcast.ioc;

public class UserDao {
	public void test() {
		System.out.println("dao......");
	}
}

（1）在service得到dao对象

package com.itcast.ioc;

public class UserService {
	// 1定义dao类型属性
	private UserDao userDao;

	// 2生成set方法
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	public void add() {
		System.out.println("service......");
	   //在service里面得到dao类对象，才能调用dao里面的方法
		/*UserDao dao=new UserDao();
		dao.add();*/
		userDao.test();
	}
}

2.具体实现过程：
（1）在service里面把dao作为类型属性
（2）生成dao类型属性的set方法

public class UserService {
	// 1定义dao类型属性
	private UserDao userDao;

	// 2生成set方法
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

（3）在配置文件中完成对象类型属性值注入

<!--注入对象类型属性 -->
	<!--1配置service和dao对象 -->
	<bean id="userDao" class="com.itcast.ioc.UserDao"></bean>
	<bean id="userService" class="com.itcast.ioc.UserService">
		<!--注入dao对象 
		name属性值：service类里面属性名称   
		        现在不要写value属性，因为现在不是字符串，现在是对象   
		 写ref属性：dao配置bean标签中的id值 -->
		<property name="userDao" ref="userDao"></property>
	</bean>

（4）测试

@Test
	public void test5() {
		// 加载配置文件，根据创建对象
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 得到配置创建的对象
	    UserService userService=(UserService) context.getBean("userService");
	    userService.add();
	}

结果：
在这里插入图片描述

P名称空间注入

配置文件头部需要加入空间配置：

 xmlns:p="http://www.springframework.org/schema/p"

具体实现过程：
1.Person.java类

package com.itcast.property;

public class Person {
	private String pname;

	public void setPname(String pname) {
		this.pname = pname;
	}

	public void test1() {
		System.out.println("person..." + pname);
	}
}

2.配置文件：
在这里插入图片描述
3.测试：

@Test
	public void test6() {
		// 加载配置文件，根据创建对象
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 得到配置创建的对象
		Person person = (Person) context.getBean("person");
		person.test1();
	}

结果：person...lucy

注入复杂类型属性

实例：
TestEntity.java

package com.itcast.entity;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import com.itcast.ioc.User;

public class TestEntity {
	private String specialCharacter1; // 特殊字符1
	private String specialCharacter2; // 特殊字符2
	private User innerBean; // javaBean 类型
	private List<String> list; // List类型
	private String[] array; // 数组类型
	private Set<String> set; // set类型
	private Map<String, String> map; // map类型
	private Properties props; // peoperties 类型
	private String emptyValue; // 注入空字符串值
	private String nullValue = "init value"; // 注入null值

	public String getSpecialCharacter1() {
		return specialCharacter1;
	}

	public void setSpecialCharacter1(String specialCharacter1) {
		this.specialCharacter1 = specialCharacter1;
	}

	public String getSpecialCharacter2() {
		return specialCharacter2;
	}

	public void setSpecialCharacter2(String specialCharacter2) {
		this.specialCharacter2 = specialCharacter2;
	}

	public User getInnerBean() {
		return innerBean;
	}

	public void setInnerBean(User innerBean) {
		this.innerBean = innerBean;
	}

	public List<String> getList() {
		return list;
	}

	public void setList(List<String> list) {
		this.list = list;
	}

	public String[] getArray() {
		return array;
	}

	public void setArray(String[] array) {
		this.array = array;
	}

	public Set<String> getSet() {
		return set;
	}

	public void setSet(Set<String> set) {
		this.set = set;
	}

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

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

	public Properties getProps() {
		return props;
	}

	public void setProps(Properties props) {
		this.props = props;
	}

	public String getEmptyValue() {
		return emptyValue;
	}

	public void setEmptyValue(String emptyValue) {
		this.emptyValue = emptyValue;
	}

	public String getNullValue() {
		return nullValue;
	}

	public void setNullValue(String nullValue) {
		this.nullValue = nullValue;
	}

}
User.java
package com.itcast.ioc;

public class User {
	private String username;

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}
}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<!--引入Schema约束 -->
<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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--注入复杂属性类型  -->
    <bean id="testEntity" class="com.itcast.entity.TestEntity">
        <property name="specialCharacter1">
            <!--使用<![CDATA[]]>处理特殊字符或者将特殊字符转化成实体引用-->
            <value><![CDATA[P&G]]></value>
        </property>
        <property name="specialCharacter2">
            <value>P&amp;G&gt;</value>
        </property>
        <!--引用内部JavaBean-->
        <property name="innerBean">
            <bean class="com.itcast.ioc.User">
                <property name="username">
                    <value>扎根三</value>
                </property>
            </bean>
        </property>
        <!--配置list集合类型的值-->
        <property name="list">
            <list>
                <value>足球</value>
                <value>篮球</value>
            </list>
        </property>
        <!--配置array数组类型的值-->
        <property name="array">
            <list>
                <value>足球</value>
                <value>篮球</value>
            </list>
        </property>
        <!--配置set集合类型的值-->
        <property name="set">
            <set>
                <value>华硕</value>
                <value>联想</value>
            </set>
        </property>
        <!--配置map属性值-->
        <property name="map">
            <map>
                <!--定义map中的键值对-->
                <entry>
                    <key><value>football</value></key>
                    <value>足球</value>
                </entry>
                <entry>
                    <key><value>basketball</value></key>
                    <value>篮球</value>
                </entry>
            </map>
        </property>
        <property name="props">
            <props>
                <!--定义properties中的键值对-->
                <prop key="football">足球</prop>
                <prop key="basketball">篮球</prop>
            </props>
        </property>
        <!--注入空字符串-->
        <property name="emptyValue"><value></value></property>
        <!--注入null值-->
        <property name="nullValue"><null/></property>
   </bean>
</beans>

测试：

@Test
	public void test7() {
		// 加载配置文件，根据创建对象
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		// 得到配置创建的对象
		TestEntity testEntity = (TestEntity) context.getBean("testEntity");
		System.out.println(" 特殊字符1：" + testEntity.getSpecialCharacter1());
		System.out.println(" 特殊字符2：" + testEntity.getSpecialCharacter2());
		System.out.println("javaBean 类型 姓名：" + testEntity.getInnerBean().getUsername());
		System.out.println("List类型：" + testEntity.getList());
		System.out.println("数组类型：" + testEntity.getArray()[0] + "\t" + testEntity.getArray()[1]);
		System.out.println("set类型：" + testEntity.getSet());
		System.out.println("map类型：" + testEntity.getMap());
		System.out.println("peoperties 类型：" + testEntity.getProps());
		System.out.println("注入空字符串值：[" + testEntity.getEmptyValue() + "]");
		System.out.println("注入null值：" + testEntity.getNullValue());
	}

结果：

特殊字符1：P&G
 特殊字符2：P&G>
javaBean 类型 姓名：扎根三
List类型：[足球, 篮球]
数组类型：足球	篮球
set类型：[华硕, 联想]
map类型：{football=足球, basketball=篮球}
peoperties 类型：{football=足球, basketball=篮球}
注入空字符串值：[]
注入null值：null

IOC 与 DI 的区别

（1）IOC ：控制反转，把对象创建交给spring进行配置
（2）DI ：依赖注入，向类里面的属性中设置值
（3）关系：依赖注入不能单独存在，需要在ioc基础上完成操作
Spring整合web项目原理
1.加载spring核心配置文件

// 加载配置文件，根据创建对象
ApplicationContext context = 
new ClassPathXmlApplicationContext("applicationContext.xml");

（1）new 对象，功能可以实现，效率很低
2.实现思想：把加载配置文件和创建对象过程，在服务器启动时候完成。
3.底层实现原理：
（1）ServletContext对象
（2）监听器
（3）具体使用：
— 在服务器启动的时候，为每个项目创建一个ServletContext对象；
— 在ServletContext对象创建的时候，使用监听器可以具体到ServletContext对象在什么时候创建；
— 使用监听器监听到ServletContext对象创建时候，
— 加载spring配置文件，把配置文件配置对象创建；
— 把创建出来的对象放到ServletContext域对象里面（setAttribute方法）；
— 获取对象时候，到ServletContext域得到（getAttribute方法）

高风言

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
Spring框架知识点（一）

Spring是一站式框架1.spring在JavaEE三层结构中，每一层都提供不同的解决技术Web 层：springMVCService 层：spring 的 iocDao 层：spring 的 jdbcTemplateSpring 概念1. spring 是开源的轻量级框架2. spring 核心主要两部分：（1）Aop：面向切面编程，扩展功能不是修改源代码实现（2）Ioc ：...
复制链接

扫一扫