Spring基础入门（一）

一、Spring概念

1.什么是Spring

  Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。  -----转自百度百科

  简单来说，Spring 是一个分层的 JavaSE/EEfull-stack(一站式) 轻量级开源框架。

2.为什么要学习Spring###

• 方便解耦，简化开发
  
  Spring 就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring 管理
• AOP 编程的支持
  
  Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
• 声明式事务的支持
  
  只需要通过配置就可以完成对事务的管理，而无需手动编程
• 方便程序的测试
  
  Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程序
• 方便集成各种优秀框架
  
  Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz 等）的直接支持
• 降低 JavaEE API 的使用难度
  
  Spring 对 JavaEE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等），都提供了封装，
  
  使这些 API 应用难度大大降低

3.Spring核心##

• 1.ioc：控制反转（对象的创建不是new出来的，而是通过Spring配置创建）
• 2.aop:面向切面编程（拓展功能不通过修改源代码实现）

二、Spring的IOC操作#

这里使用IDEA创建Spring项目，IDEA会自动帮你下载Spring所需要的jar包，也可以选择是否帮你创建spring配置文件###

IDEA生成的配置文件“spring-config.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

你也可以选择自己创建一个配置文件,如图所示

• 注意：spring核心配置文件名称和位置不是固定的，建议放到src下面，官方建议applicationContext.xml

1.通过xml实现ioc操作##

（1）通过无参构造方法创建

 Spring可以通过类的无参构造来创建bean

 ①首先创建一个Bean1.java

    package com.spring.test_1;

    public class Bean1 {
        public void test()
        {
            System.out.print("test bean...");
        }
    }

②然后在idea创建的spring-config.xml中做如下配置,这里id是用来获取配置对象的，class是类的路径。

    <bean id="bean1" class="Bean1"></bean>

这里要引入schema约束，否则会在之后加载配置文件时会出现错误提示，在联网的情况下，idea会自动帮你导入，无网络的话，也可以自己手动导入，这里不再详解。

③写代码测试对象创建

@Test
public void fun1() {
            //加载配置文件
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
            //通过id创建对象
            Bean1 bean1 = (Bean1) applicationContext.getBean("bean1");
            //调用test方法
            bean1.test();
        }

注意：如果类中没有无参构造的话会抛出异常（No default constructor found）

测试结果如下：

(2)通过静态工厂创建

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

package com.spring.test_1;

public class Bean2Factory {
    public static Bean2 getBean2()
    {
        return  new Bean2();
    }

}

②使用静态工厂创建对象

<bean id="bean2" class="com.spring.test_1.Bean2Factory" factory-method="getBean2"></bean>

③测试用例

@Test
    public void fun2() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
        Bean2 bean2 = (Bean2) applicationContext.getBean("bean2");
        bean2.test2();
    }

(3)通过实例工厂创建

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

package com.spring.test_1;

public class Bean3Factory {
    public Bean3 getBean3()
    {
        return  new Bean3();
    }
}

②使用实例工厂创建对象

<!-- 使用实例工厂创建对象 -->
<!-- 创建工厂对象 -->
<bean id="bean3Factory" class="com.spring.test_1.Bean3Factory"></bean>
<bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3"></bean>

测试用例：

@Test
public void fun3() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
    Bean3 bean3 = (Bean3) applicationContext.getBean("bean3");
    bean3.test3();
}

2.Bean标签属性##

（1）id属性：起名称，id属性值名称任意命名

• id属性值，不能包含特殊符号
• 根据id值得到配置对象

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

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

（4）scope属性

• singleton：默认值，单例，创建的对象在系统中只有一份

    <bean id="bean1" class="Bean1" scope="singleton"></bean>
  

测试用例：

    @Test
        public void fun4() {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
            Bean1 bean1 = (Bean1) applicationContext.getBean("bean1");
            Bean1 bean2 = (Bean1) applicationContext.getBean("bean1");
            System.out.println(bean1);
            System.out.println(bean2);
        }

测试结果：

• prototype：多例，每一次创建都对应一个新的对象

    bean id="bean1" class="com.spring.test_1.Bean1" scope="prototype"></bean>
  

测试结果：

• request：创建对象把对象放到request域里面
• session：创建对象把对象放到session域里面
• globalSession：创建对象把对象放到globalSession里面

3.属性注入##

（1）属性注入有三种方式###

• 使用set方法注入
• 使用有参构造注入
• 使用接口注入

 注意：spring支持前两种方式

①使用有参构造注入

<!--使用有参构造注入属性-->
<bean id="user" class="com.spring.test_2.User">
    <constructor-arg name="username" value="张三"></constructor-arg>
    <constructor-arg name="password" value="123456"></constructor-arg>
</bean>

user.java

public class User {
    private String username;
    private String password;

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

配置文件中注入的属性必须与有参构造的参数相同，否则会报错。

②使用set()注入

使用set注入时，类中必须存在属性的set方法

<!--使用set()注入-->
<bean id="user2" class="com.spring.test_2.User2">
    <property name="username" value="李四"></property>
</bean>

user2.java

public class User2 {
    private String username;

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

    @Override
    public String toString() {
        return "User2{" +
                "username='" + username + '\'' +
                '}';
    }
}

（2）注入对象类型属性###

首先新建一个UserService.java

public class UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void testService() {
        userDao.testDao();
        System.out.println("UserService...");
    }
}

然后创建一个UserDao.java

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

再在配置文件中进行如下配置

<!--注入对象类型属性-->
<bean id="userDao" class="com.spring.test_2.UserDao"></bean>
<bean id="userService" class="com.spring.test_2.UserService">
    <property name="userDao" ref="userDao"></property>
</bean>

注意：property中的ref必须与UserDao的bean的id相同

测试结果：

（3）注入复杂类型属性###

新建一个ComplexPro类，其中包括array，list，map以及properties这四种属性，并生成各自的set方法。

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

public class ComplexPro {
    private String[] arrs;
    private List<String> list;
    private Map<String , String> map;
    private Properties properties;

    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }

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

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

    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    public void test()
    {
        System.out.println("arrs"+arrs);
        System.out.println("list"+list);
        System.out.println("map"+map);
        System.out.println("properties"+properties);
    }

}

在spring-config.xml中进行配置

<!--注入复杂类型属性-->
    <bean id="complexPro" class="com.spring.test_2.ComplexPro">
        <property name="arrs">
            <list>
                <value>张三</value>
                <value>李四</value>
                <value>王五</value>
            </list>
        </property>
        <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
                <value>王五</value>
            </list>
        </property>
        <property name="map">
            //map中保存的是一个个键值对
            <map>
                <entry key="张三" value="123"></entry>
                <entry key="李四" value="456"></entry>
                <entry key="王五" value="789"></entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="username">root</prop>
                <prop key="password">123</prop>

            </props>
        </property>
    </bean>

测试结果：

（4）IOC与DI的区别###

• IOC: 控制反转，把对象创建交给spring进行配置
• DI: 依赖注入，向类里面的属性中设置值
• 两者关系：依赖注入不能单独存在，需要在ioc基础之上完成操作

4.通过注解实现IOC操作##

1.注解创建对象###

 注解实现ioc很简单，只需要在配置文件中开启注解扫描就可以使用注解了

 使用注解需要引入新约束

    "http://www.springframework.org/schema/context/spring-context.xsd"

 联网状态idea会自动引入

<!--注解扫描-->
<!--扫描包中的类、方法、属性上的注解-->
<context:component-scan base-package="com.spring.test_3"></context:component-scan>

<!--只扫描属性上的注解，一般不推荐使用-->
<!--<context:annotation-config></context:annotation-config>-->

注意：这里的base-package属性是扫描范围，多个包之间用空格隔开，但是同一个包内可以扩大范围，比如说com.spring就是扫描com.spring包以及子包的所有类

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component(value = "user") //value可省略
//spring提供了@Component的三个衍生注解，但目前来说功能一样
/*
    @Service("user")
    @Controller("user")
    @Repository("user")
*/

@Scope(value = "prototype")//创建对象是单例还是多例
public class User {
    @Value("李四")
    private String username;
    public void test() {
        System.out.println("注解创建对象....");
    }
    public void testUsername()
    {
        System.out.print("username="+username);
    }
}

2.注解注入属性###

（1）注入普通属性

@Value("李四")
private String username;

（2）注入对象属性

创建UserService类和UserDao类，并创建对象

import org.springframework.stereotype.Controller;

@Controller("userDao")
public class UserDao {

    public void testDao()
    {
        System.out.println("userDao....");
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

public class UserService {
    private  UserDao userDao;
    public void testService()
    {
        userDao.testDao();
        System.out.println("userService....");
    }
}

在service中定义dao属性

@Autowired
private  UserDao userDao;
//使用注解不需要set方法
//注入属性第二个注解Resourc(name = "userDao")

本节的Demo已上传github，如有需要请下载###

https://github.com/LELE-QAQ/TestSpring