Spring优势

  1. 方便解耦，简化开发

  2. AOP编程的支持

  3. 声明式事务的支持

  4. 方便程序的测试

  5. 方便集成各种优秀框架

  6. 降低JavaEE API的使用难度

  7. Java源码时经典的学习范例

Spring体系结构

QQ截图20220303104112.jpg

开发步骤

QQ截图20220303104342.jpg

导入Spring开发的基本坐标

pom.xml中：

  1.   <dependencies>
  2.     <dependency>
  3.       <groupId>com.woniuxy</groupId>
  4.       <artifactId>maven_spring</artifactId>
  5.       <version>1.0-SNAPSHOT</version>
  6.     </dependency>
  7.   </dependencies>

创建接口并实现接口

  1. //接口类中：
  2. public interface UserDao {
  3.     void save();
  4. }
  6. //实现类中：
  7. public class UserDaoImpl implements UserDao {
  8.     public void save(){
  9.         System.out.println("save");
  10.     }
  11. }

在resources下创建Spring核心配置文件并配置bean

  1. //通过该标识让spring托管类的实现 
  2. <bean id="唯一标识" class="类的全限定名"></bean>

调用

  1.     //用ApplicationContext的getBean对象调用applicationContext.xml容器中id为userDao的对应的类
  2.     //中的save()方法        
  3.     ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
  4.     UserDao userDao = (UserDao) app.getBean("userDao");
  5.     userDao.save();

配置文件

scope：Bean的范围配置

singleton:单例

  1. 个数：一个
  2. 实例化时机：随srping核心文件一起加载

  3. 生命周期：随容器共存亡

    prototype

  4. 个数：多个

  5. 实例化时机：每次调用getBean()时实例化一个全新的对象
  6. 生命周期：长时间不使用，就会被垃圾回收

    request

    略

    session

    略

    gloal session

    略

Bean生命周期配置

init-method和destroy-method

初始化方法和销毁方法
销毁方法只有在方法销毁前执行，所以需要调用close()方法手动关闭方法，才能让销毁方法执行。

factory-method

该方法在close()执行之前触发

Bean实例化三种方式

无参构造实例化

  1. <bean id="唯一标识" class="类的全限定名"></bean>

工厂静态方法实例化

  1. <bean id="唯一标识" class="类的全限定名" factory-method="静态方法名"></bean>

工厂实例方法实例化

  1. <bean id="类的唯一标识" class="类的全限定名" factory-method="静态方法名"></bean>
  2. <bean id="方法的唯一标识" factory-bean="类的唯一标识" factory-method="方法名"></bean>

Bean的依赖注入

用A对象调用B对象

bean内部注入

set注入

  1. public class UserServiceImpl implements UserService {
  3.     private UserDao userDao;
  5.     public void setUserDao(UserDao userDao) {
  6.         this.userDao = userDao;
  7.     }
  9.     public void save() {
  10.         userDao.save();
  11.     }
  12. }
  1. //property方法
  2.   <bean id="userDao" class="com.itheima.dao.impl.UserDao"></bean>
  4.   <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
  5.     <property name="userDao" ref="userDao"/> //ref表示引用上面的id为userDao的bean
  6.   </bean>
  8. --------------------------------------------------------------------------------------
  10. //p命名空间方法
  11. beans中加入：xmlns:p="http://www.springframework.org/schema/p"
  12.   <bean id="userDao" class="com.itheima.dao.impl.UserDao"></bean>
  14.   <bean id="userService" class="com.itheima.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

构造方法注入

  2. public class UserServiceImpl implements UserService {
  4.     private UserDao userDao;
  6.     public UserServiceImpl(UserDao userDao) {
  7.         this.userDao = userDao;
  8.     }
  10.     public void save() {
  11.         userDao.save();
  12.     }
  13. }
  1. <bean id="userDao" class="com.itheima.dao.impl.UserDao"/>
  3. <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
  4.     <constructor-arg name="userDao" ref="userDao" />
  5. </bean>

外部自动注入

在beans标签添加default-autowire=""设置注入类型：

  1. byName：根据对象名称装配，用setter()获取
  2. byType：根据对象类型装配， 用setter()获取，只能存在一个该类型的bean，否则会报错
  3. constructor：根据构造方法装配，构造参数使用byType()匹配
  4. default：手动装配

    Bean注入的数据类型（了解）

    引用类型

    上面已经举过例子

普通数据类型

  1. @Data
  2. public class UserDaoImpl implements UserDao {
  4.     private String username;
  5.     private int age;
  7.     public void save() {
  8.         System.out.println(username+"---"+age);
  9.         System.out.println("save running");
  10.     }
  11. }
  1.     <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
  2.         <property name="username" value="徐志康"></property>
  3.         <property name="age" value="22"></property>
  4.     </bean>

集合类型

List

  1.     <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
  2.         <property name="strList">
  3.             <list>
  4.                 <value>aaa</value>
  5.                 <value>bbb</value>
  6.                 <value>ccc</value>
  7.             </list>
  8.         </property>
  9.     </bean>

Map

  1.     <bean id="user1" class="com.itheima.dommain.User">
  2.         <property name="name" value="徐志康1"></property>
  3.         <property name="addr" value="123"></property>
  4.     </bean>
  6.     <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
  7.         <property name="userMap">
  8.             <map>
  9.                 <entry key="user1" value-ref="user1"></entry>
  10.             </map>
  11.         </property>
  12.     </bean>

Properties

  1.     <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
  2.         <property name="properties">
  3.             <props>
  4.                 <prop key="p1">ppp1</prop>
  5.                 <prop key="p2">ppp2</prop>
  6.                 <prop key="p3">ppp3</prop>
  7.             </props>
  8.         </property>
  9.     </bean>

引入其他配置文件（分模块开发）

  1. <import resource="applicationContext-user.xml"/>

Spring相关API

ApplicationContext的实现类

ClassPathXmlApplicationContext

从相对路径下加载配置文件，推荐使用

FileSystemXmlApplicationContext

从绝对路径下加载配置文件

AnnotationConfigApplicationContext

当使用注解配置容器对象时，需要使用此类创建spring容器。他用来读取注解

getBean()方法使用

  1. app.getBean(类名.class);容器内只有一个该类型的bean，当容器内配置多个该类型的对象时，返回最后一个对象
  2. app.getBean("userService");使用对象接收时，需要进行强制转换
  3. app.getBean("userService",UserService.class);声明对象类型，不需要强转，推荐使用

Spring注解开发

Spring原始注解