Spring目前用到的知识点

2022-11-20 14:38:24

2017/7/28

目前的工作，spring用到到的地方

在当前类有下列的代码

private BookDao bookDao

bookDao.调用方法

点开这个方法，声明指向的是BookDao这个接口的声明，实现指向的是BookDaoImpl这个实现类

Spring目前用到的知识点

以前是接口  引用变量 =new 实现类（）

现在是接口+setter

使用set方法注入属性（重点）:

  1. package cn.ywq.property;
  2. public class Book {
  3.     private String bookname;  
  4. //set方法
  5.    public void setBookname(String bookname) {  
  6.         this.bookname = bookname;  
  7.     }  
  8. public void demobook() {
  9. System.out.println("book..........."+bookname);
  10. }
  11. }

配置文件：

这个配置文件，既给其他类提供了对象（用这个对象可以调用方法）

也给自己这个对象设置了属性

  1. <!-- 使用set方法注入属性 -->
  2. <bean id="book" class="cn.itcast.property.Book">   //在测试类里面可以用Book book =get（BeanID）
  3. <!-- 注入属性值
  4. name属性值：类里面定义的属性名称
  5. value属性：设置具体的值
  6. -->
  7. <property name="bookname" value="易筋经"></property>
  8. </bean>

前面属性注入都是将简单的字符串作为属性注入到了某个对象中，那么如何注入对象类型的属性呢？（重点）
我们以Service中得到Dao对象为例来进行演示。

创建service类和dao类：
（1）在service得到dao对象

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

UserService.java

  1. package cn.ywq.ioc;
  2. public class UserService {
  3. //1 定义dao类型属性
  4. private UserDao userDao;
  5. //2 生成set方法
  6. public void setUserDao(UserDao userDao) {
  7. this.userDao = userDao;
  8. }
  9. public void add() {
  10. System.out.println("service.........");
  11.  userDao.add();   //点开这个方法,点击声明或者实现
  12. }
  13. }

UserDao.java

  1. public class UserDao {
  2. public void add() ；
  3. }   
    //UserDaoImpl
    
public class UserDaoImpl{
    
      public void add（）{
    
           System.out.println("11111111");
    
     }
    
}

    　　

配置文件：

  1. <!-- 注入对象类型属性 -->
  2. <!-- 1 配置service和dao对象 -->
  3. <bean id="userDao" class="cn.ywq.ioc.UserDao"></bean>
  4. <<bean id="userService" class="cn.ywq.ioc.UserService">
  5. <!--  注入dao对象
  6. name属性值：service类里面属性名称
  7. 现在不要写value属性，因为刚才是字符串，现在是对象
  8. 写ref属性：dao配置bean标签中id值 -->
  9. <property name="userDao" ref="userDao"></property>
  10. </bean>

注入复杂类型属性

如何注入复杂类型属性呢？复杂类型包括：数组、list集合、map集合以及properties类型。

举例：在User对象中注入各种复杂类型属性。

    1. <!-- 注入复杂类型属性值 -->
    2. <bean id="user" class="cn.ywq.property.User">
    3. <!-- 数组 -->
    4. <property name="arrs">
    5. <list>
    6. <value>小王</value>
    7. <value>小马</value>
    8. <value>小宋</value>
    9. </list>
    10. </property>
    11. <!-- list -->
    12. <property name="list">
    13. <list>
    14. <value>小奥</value>
    15. <value>小金</value>
    16. <value>小普</value>
    17. </list>
    18. </property>
    19. <!-- map -->
    20. <property name="map">
    21. <map>
    22. <entry key="aa" value="lucy"></entry>
    23. <entry key="bb" value="mary"></entry>
    24. <entry key="cc" value="tom"></entry>
    25. </map>
    26. </property>
    27. <!-- properties -->
    28. <property name="properties">
    29. <props>
    30. <prop key="driverclass">com.mysql.jdbc.Driver</prop>
    31. <prop key="username">root</prop>
    32. </props>
    33. </property>
    34. </bean>

spring是开源的轻量级框架，核心主要两部分：

（1）aop：面向切面编程，扩展功能不是修改源代码实现

顺平说，在不修改源代码的基础上还增添功能

（2）ioc：控制反转，

- 比如有一个类，在类里面有方法（不是静态的方法），调用类里面的方法，创建类的对象，使用对象调用方法，创建类对象的过程，需要new出来对象

- 把对象的创建不是通过new方式实现，而是交给spring配置创建类对象

spring也是一站式框架

（1）spring在javaee三层结构中，每一层都提供不同的解决技术

- web层：springMVC

- service层：spring的ioc

- dao层：spring的jdbcTemplate

Spring中对bean标签的管理：

Spring里边是通过配置文件来创建对象的，即其有IOC控制反转机制，每一个bean的实例化就是在创建一个对象。bean实例化有三种实现方式：

（1）使用类的无参构造函数来创建（重点）

比如说有一个User类：

  1. package cn.itcast.ioc;
  2. public class User {
  3. private String username;
  4. public User() {
  5. }
  6. }

则只需要在核心配置文件中：

  1. <bean id="user" class="cn.ywq.User" ></bean>

即可完成对象的创建（bean的实例化），若User类中没有无参构造，则会报异常。

注：在test类中，只需要User user  = getBeans，用user就可以去调用方法

（2）使用静态工厂创建：

创建静态的方法，返回类对象

  1. package cn.ywq.bean;
  2. public class Bean2Factory {
  3. //静态的方法，返回Bean2对象
  4. public static Bean2 getBean2() {
  5. return new Bean2();
  6. }
  7. }
  1. <bean id="bean2" class="cn.ywq.bean.Bean2Factory" factory-method="getBean2"></bean>

（3）使用实例工厂创建

创建不是静态的方法，返回类对象 n

  1. package cn.ywq.bean;
  2. public class Bean3Factory {
  3. //普通的方法，返回Bean3对象
  4. public Bean3 getBean3() {
  5. return new Bean3();
  6. }
  7. }
  1. <bean id="bean3Factory" class="cn.ywq.bean.Bean3Factory"></bean>
  2. <bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3"></bean>

Bean标签的常用属性：

（1）id属性：起名称，id属性值名称任意命名
- id属性值，不能包含特殊符号
- 根据id值得到配置对象

（2）class属性：创建对象所在类的全路径

（3）name属性：功能和id属性一样的，id属性值不能包含特殊符号，但是在name属性值里面可以包含特殊符号

（4）scope属性
- singleton：默认值，单例
- prototype：多例
 - request：创建对象把对象放到request域里面
- session：创建对象把对象放到session域里面
- globalSession：创建对象把对象放到globalSession里面

属性注入：

上边介绍了通过配置文件，有三种方法可以实现对象的创建，那么如何向对象的属性中设置值呢？这就需要用到注入的方法。

属性注入的方式介绍（三种方式）
（1）使用set方法注入
（2）使用有参数构造注入
（3）使用接口注入
Spring目前用到的知识点

在spring框架里面，支持前两种方式

（1）set方法注入（重点）

（2）有参数构造注入

有参构造注入：

  1. package cn.ywq.property;
  2. public class PropertyDemo1 {
  3. private String username;
  4. public PropertyDemo1(String username) {
  5. this.username = username;
  6. }
  7. public void test1() {
  8. System.out.println("demo1.........."+username);
  9. }
  10. }

配置文件：

  1. <!-- 使用有参数构造注入属性 -->
  2. <bean id="demo" class="cn.itcast.property.PropertyDemo1">
  3. <!-- 使用有参构造注入 -->
  4. <constructor-arg name="username" value="小王小马"></constructor-arg>
  5. </bean>

使用set方法注入属性（重点）:

  1. package cn.ywq.property;
  2. public class Book {
  3. private String bookname;
  4. //set方法
  5. public void setBookname(String bookname) {
  6. this.bookname = bookname;
  7. }
  8. public void demobook() {
  9. System.out.println("book..........."+bookname);
  10. }
  11. }

配置文件：

  1. <!-- 使用set方法注入属性 -->
  2. <bean id="book" class="cn.itcast.property.Book">
  3. <!-- 注入属性值
  4. name属性值：类里面定义的属性名称
  5. value属性：设置具体的值
  6. -->
  7. <property name="bookname" value="易筋经"></property>
  8. </bean>

前面属性注入都是将简单的字符串作为属性注入到了某个对象中，那么如何注入对象类型的属性呢？（重点）
我们以Service中得到Dao对象为例来进行演示。

创建service类和dao类：
（1）在service得到dao对象

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

UserService.java

  1. package cn.ywq.ioc;
  2. public class UserService {
  3. //1 定义dao类型属性
  4. private UserDao userDao;
  5. //2 生成set方法
  6. public void setUserDao(UserDao userDao) {
  7. this.userDao = userDao;
  8. }
  9. public void add() {
  10. System.out.println("service.........");
  11. userDao.add();
  12. }
  13. }

UserDao.java

  1. package cn.ywq.ioc;
  2. public class UserDao {
  3. public void add() {
  4. System.out.println("dao.........");
  5. }
  6. }

配置文件：

  1. <!-- 注入对象类型属性 -->
  2. <!-- 1 配置service和dao对象 -->
  3. <bean id="userDao" class="cn.ywq.ioc.UserDao"></bean>
  4. <<bean id="userService" class="cn.ywq.ioc.UserService">
  5. <!--  注入dao对象
  6. name属性值：service类里面属性名称
  7. 现在不要写value属性，因为刚才是字符串，现在是对象
  8. 写ref属性：dao配置bean标签中id值 -->
  9. <property name="userDao" ref="userDao"></property>
  10. </bean>

注入复杂类型属性

如何注入复杂类型属性呢？复杂类型包括：数组、list集合、map集合以及properties类型。

举例：在User对象中注入各种复杂类型属性。

  1. <!-- 注入复杂类型属性值 -->
  2. <bean id="user" class="cn.ywq.property.User">
  3. <!-- 数组 -->
  4. <property name="arrs">
  5. <list>
  6. <value>小王</value>
  7. <value>小马</value>
  8. <value>小宋</value>
  9. </list>
  10. </property>
  11. <!-- list -->
  12. <property name="list">
  13. <list>
  14. <value>小奥</value>
  15. <value>小金</value>
  16. <value>小普</value>
  17. </list>
  18. </property>
  19. <!-- map -->
  20. <property name="map">
  21. <map>
  22. <entry key="aa" value="lucy"></entry>
  23. <entry key="bb" value="mary"></entry>
  24. <entry key="cc" value="tom"></entry>
  25. </map>
  26. </property>
  27. <!-- properties -->
  28. <property name="properties">
  29. <props>
  30. <prop key="driverclass">com.mysql.jdbc.Driver</prop>
  31. <prop key="username">root</prop>
  32. </props>
  33. </property>
  34. </bean>

IOC（控制反转）和DI（依赖注入）的关系：

（1）IOC: 控制反转，把对象创建交给spring进行配置

（2）DI: 依赖注入，向类里面的属性中设置值

（3）关系：依赖注入不能单独存在，需要在ioc基础之上完成操作

上一篇：用Total Commander替换windos默认资源管理器


下一篇：Linux编辑器篇-分享10个最好的Markdown编辑器