目录

Spring学习(一)

Spring学习笔记,仅供自己参考。

概述

  1. Spring是开源的轻量级框架。
  2. Spring核心主要为两部分: (1).AOP:面向切面编程 (2).IOC:控制反转: 把对象的创建不是通过new的方式实现,而是交给spring配置创建类对象
  3. Spring是一站式框架。 Spring在JavaEE三层结构中,每一层都提供不同的解决技术。
  • web层:SpringMVC
  • service层:Spring的ioc
  • dao层:Spring的jdbcTemplate
  1. Spring版本:4.x

接口

  • 用于沟通的中介勿的抽象化。
  • 对外声明。
  • Java 8中接口可以拥有方法体。

面向接口编程

  • 结构设计中,分清层次及调用关系,每层只能向外提供一组功能接口,更层次仅依赖接口而非实现类。
  • 接口实现的变动不影响各层的调用。
  • 隐藏具体实现和实现多态性的组件。

IOC 控制反转

什么是IOC

控制权的转移,应用程序本身不负责依赖对象的创建和维护,而是由外部容器负责创建和维护。 把对象的创建交给spring进行管理

IOC操作的两种操作

  • IOC的基于配置文件方式
  • IOC的注解方式

IOC的底层原理

  1. xml的配置文件
  2. dom4j解决xml
  3. 工厂设计模式
  4. 反射

IOC案例

  1. 导入jar包
  • 核心jar包 Beans Core Context, SpEL
  • 支持日志输出的jar包
  1. 创建类,在类里面创建方法
  2. 创建spring的配置文件,配置创建类
  • 建议放到src下面
  1. 测试对象创建

Spring的Bean管理(xml)

实例化三种方式

  • 使用类的无参构造(主要使用方式)
  • 静态工厂创建
  • 实例工厂创建

Bean标签常用属性

  • id属性 起名称,id的属性值可以是任意命名,但是不能包含特殊符号
  • class属性 创建对象所在类的全路径
  • name属性 功能和id属性是一样的,但是name属性可以包含特殊符号。
  • scope属性 singleton:默认值,单例对象。 prototupe:多例。 request:创建了对象,把对象放到request域里面。 session:创建对象,把对象放到session里面。 globalSession:创建对象,把对象放到globalSession里面。

Spring的Bean的管理(注解)

注解

  • 代码里面的特殊标记,使用注解可以完成功能。
  • 注解写法@注解名称(属性名称=属性值)
  • 注解使用在类上面,方法上面和属性上面。

xml需要配置一下

1
 <context:component-scan base-package="com.young.anno"/>

Bean管理常用注解

  • Component – 在Spring中提供的@Component三个衍生注解
    • @Controller WEB层
    • @Service 业务层
    • @Repository 持久层 这四个注解目前的功能是一样的,都是创建对象。
1
2
3
4
5
6
@Component(value = "user")
public class User {
    public void add(){
        System.out.println("add....");
    }
}
  • Scope 用于单例与多例等配置,写在Component的下面。
1
2
3
4
5
6
7
@Component(value = "user")
@Scope(value = "prototype") 
public class User {
    public void add(){
        System.out.println("add....");
    }
}
  • Autowired 注入属性

  • Resource name属性写创建dao对象的value值

DI 依赖注入

创建对象并且组装对象之间的关系

有参构造注入

采用constructor-arg来进行,namevalue进行对构造器的值进行注入。

1
2
3
<bean id="preperty" class="com.young.property.PrepertyDemo1">
        <constructor-arg name="username" value="zhangsan"/>
</bean>

set方法注入

使用property标签进行注入,name定义类里面定义的属性的名称,value设置具体的值

1
2
3
<bean id="book" class="com.young.property.Book">
        <property name="bookname" value="one"/>
</bean>
  • spring框架只支持set方法注入和构造器注入

注入对象类型属性

  • 创建service类dao类
  • 在service把dao作为类型属性
  • 生成dao类型的set方法

xml配置方式

  • UserService.java
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
public class UserService {
    private UserDao userDao;
    public void add(){
        System.out.println("service");
        userDao.add();
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}
  • 配置文件
1
2
3
4
5
    <bean id="service" class="com.young.ioc.UserService">
        <!--不能写value属性,要写ref,dao配置bean标签的id值-->
        <property name="userDao" ref="userdao"></property>
    </bean>
    <bean id="userdao" class="com.young.ioc.UserDao">

注解注入方式

  1. Autowired
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
@Service(value = "userservice")
public class UserService {

    @Autowired
    private UserDao userDao;

    public void add(){
        System.out.println("service");
        userDao.add();
    }
}
  1. Resure

UserDao.java

1
2
3
4
5
6
@Component(value = "userdao")
public class UserDao {
    public void add() {
        System.out.println("UserDao");
    }
}

复杂类型注入

  • 数组
1
2
3
4
5
6
7
8
9
<!--数组类型-->
        <property name="args">
            <list>
                <value>小马</value>
                <value>小宋</value>
                <value>小王</value>
                <value>小李子</value>
            </list>
        </property>
  • list类型
1
2
3
4
5
6
    <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
            </list>
    </property>
  • map类型
1
2
3
4
5
    <property name="map">
            <map>
                <entry key="a" value="张三"/>
            </map>
    </property>
  • properties
1
2
3
4
5
    <property name="properties">
            <props>
                <prop key="name">root</prop>
            </props>
    </property>

xml和注解比较

比较项xml注解
添加<Bean id="" class=""/>@Component
多例/单例<Bean scope="prototype/>"@Scope
对象类型注入<bean id="" class=""> <property name=""ref=""></property></bean>@Resource

配置文件与注解混合使用

案例:

BookDao.java

1
2
3
4
5
public class BookDao {
    public void book(){
        System.out.println("bookDao");
    }
}

OrderDao.java

1
2
3
4
5
public class BookDao {
    public void book(){
        System.out.println("bookDao");
    }
}

BookService.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
public class BookService {

    @Resource(name = "bookDao")
    private BookDao bookDao;
    @Resource(name = "ordlerDao")
    private OrderDao ordersDao;
    
    public void service(){
        System.out.println("service");
        bookDao.book();
        ordersDao.buy();
    }
}

配置文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
<?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: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">
    <context:component-scan base-package="com.young.xmlanno"/>
    <bean id="bookservice" class="com.young.xmlanno.BookService"/>
    <bean id="bookDao" class="com.young.xmlanno.BookDao"/>
    <bean id="ordlerDao" class="com.young.xmlanno.OrderDao"/>
</beans>

测试类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    @org.junit.Test
    public void testxmlAnno(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bea2.xml");
        BookService bookService= (BookService) context.getBean("bookservice");
        bookService.service();
    }
}