Spring总结

时间：2019-08-31 15:09:56 阅读：86 评论：0 收藏：0 [点我收藏+]

标签：size 文件 inject interface injection cto property alt private

1.什么是spring?

Spring是一个分层的一站式轻量级开源框架

2.spring的使用

如果要使用spring中的东西，就必须被spring管理

2.1Spring的jar包下载与导入

Spring的官网：spring.io，下载对应的压缩文件。

2.2项目的环境搭建

1.下载好之后，打开lib，里面是所有的jar包，把RELEASE.jar结尾的包导入到新建的java项目lib中。

2.编写配置文件applicationContext.xml的约束

在项目下新建一个config的文件夹，让它变成资源目录。新建一个applicationContext.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       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">
</beans>

3.新建一个测试目录，用于做测试

2.3.IOC快速入门

IOC：inversion of Controller（控制反转），把对象的控制权交给spring。原来由我们自己实例化的对象交给spring容器来实始化，这时对象的实始化的权利就会反转。

使用spring打印HelloSpring案例：

创建一个hello的类，在里面写一个方法：

package com.test;

public class Hello {
    public void say(){
        System.out.println("hello,goodmonring");
    }
}

修改配置文件applicationContext.xml，让其交给spring管理：

<!--bean将某个java对象交给spring管理，id是给bean取名，class指定要被管理的类的路径-->
<bean id="hello" class="com.test.Hello"></bean>

测试：

@Test
public void helloTest(){
    //加载配置文件
   ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取bean对象
    Hello hello = (Hello) context.getBean("hello");
    //调用方法
    hello.say();
}

2.4DI快速入门

DI：dependency injection 依赖注入。在spring框架负责创建Bean对象时，动态将依赖对象注入到Bean组件中，简单的说就是给对象的属性注入值。

使用spring给User的属性赋值案例

1.通过属性注入值

第一步：创建user对象，添加get和set方法

package com.entity;

public class User {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }
}

第二步：把user交给spring管理并通过属性注入值

<bean id="user" class="com.entity.User">
    <!--通过属性注入值，必须提供get和set方法-->
    <property name="name" value="元慧"></property>
    <property name="age" value="23"></property>
 </bean>

第三步：测试

@Test
public void test2(){
    //加载配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取bean对象
    User user = (User) context.getBean("user");
    //调用方法
    System.out.println(user.toString());
}

2.通过构造方法注入值

第一步：给User对象添加有参构造

第二步：把user交给spring管理并通过构造方法注入值

 <bean id="user" class="com.entity.User">
        <!--构造注入内容，必须提供有参构造-->
        <constructor-arg name="name" value="123"></constructor-arg>
        <constructor-arg name="age" value="20"></constructor-arg>
 </bean>

第三步：测试

3.通过标签p/c注入

通过c标签注入

<!--通过标签c注入值，必须提供有参构造，c指构造-->
<bean id="user" class="com.entity.User" c:name="王五" c:age="20"></bean>

通过p标签注入

<!--通过标签p注入值，必须提供无参构造和set方法，p指属性-->
<bean id="user" class="com.entity.User" p:name="王五" p:age="20"></bean>

面试题：IOC和DI区别?

IOC 控制反转，是指对象实例化权利由spring容器来管理

DI 依赖注入，在spring创建对象的过程中，对象所依赖的属性通过配置注入对象中。

3.bean属性注入

3.1.ref的使用

在一个实体类中持有另一个实体类的引用，就可以用到ref属性。

car类

package com.entity;
@Getter
@Setter
@ToString
public class Car {
    private String brand;
    private double price;
    private User user;
}

注入值

<bean id="user" class="com.entity.User">
     <!--通过属性注入值，必须提供get和set方法-->
    <property name="name" value="元慧"></property>
    <property name="age" value="23"></property>
 </bean>
<bean id="car" class="com.entity.Car">
    <property name="brand" value="迈巴赫"></property>
    <property name="price" value="8000000"></property>
    <property name="user" ref="user"></property>
  </bean>

测试

@Test
public void test3(){
    //加载配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    //获取bean对象
    Car car = (Car) context.getBean("car");
    //调用方法
    System.out.println(car);
}

3.2集合属性的注入

简单类型的类

package com.entity;

import java.util.List;
import java.util.Map;
import java.util.Set;
@Getter
@Setter
@ToString
public class Coll {
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
   }

复杂类型的注入

package com.entity;

import java.util.List;
import java.util.Map;
import java.util.Set;
@Getter
@Setter
@ToString
public class Coll {
    private List<User> list;
    private Set<User> set;
    private Map<String, List<User>> map;
   }

1. list属性注入

简单类型的注入

<bean id="coll" class="com.entity.Coll">
    <property name="list">
        <list>
            <value>张三</value>
            <value>李四</value>
            <value>王五</value>
            <value>张三</value>
        </list>
    </property>
</bean>

测试

@Test
public void test5(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    Coll coll = (Coll) context.getBean("coll");
    System.out.println(coll);
}

复杂类型的注入

<bean id="user" class="com.entity.User">
    <!--通过属性注入值，必须提供get和set方法-->
   <property name="name" value="元慧"></property>
   <property name="age" value="23"></property>
</bean>
<bean id="user2" class="com.entity.User">
    <property name="name" value="郭慧"></property>
    <property name="age" value="20"></property>
</bean>
<bean id="coll" class="com.entity.Coll">
    <property name="list">
       <list>
           <ref bean="user"></ref>
           <ref bean="user2"></ref>
       </list>
    </property>
</bean>

测试结果

技术图片

1. Set属性注入

简单类型的注入

技术图片

复杂类型的注入：同list的复杂类型注入，这里只需要把list改为set即可

1. Map输入注入

简单类型的注入

<bean id="coll" class="com.entity.Coll">
    <property name="map">
        <map>
            <entry key="name" value="张三"></entry>
            <entry key="sex" value="女"></entry>
            <entry key="age" value="20"></entry>
        </map>
    </property>
</bean>

复杂类型的注入

<bean id="user" class="com.entity.User">
    <!--通过属性注入值，必须提供get和set方法-->
   <property name="name" value="元慧"></property>
   <property name="age" value="23"></property>
</bean>
<bean id="user2" class="com.entity.User">
    <property name="name" value="郭慧"></property>
    <property name="age" value="20"></property>
</bean>
<bean id="coll" class="com.entity.Coll">
    <property name="map">
       <map>
           <entry key="计算机1班" value-ref="user"></entry>
           <entry key="计算机2班" value-ref="user2"></entry>
       </map>
    </property>
</bean>

4. spring注解开发

在spring中使用注解必须进行包扫描，还有开启注解。

在applicationContext.xml文件中引入：

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

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

然后在下面开启注解，进行包扫描

<!--开启注解-->
<context:annotation-config></context:annotation-config>
<!--注解包扫描-->
<context:component-scan base-package="com.test"></context:component-scan>

4.1@Component

在类的前面加上这个注解，就可以把它交给spring管理，不需要在xml中配置，相当于xml中配置一个<bean>标签。

常用方式：在后面加个括号，括号里面给这个类起个名字

package com.test;

import org.springframework.stereotype.Component;
//把student交给spring管理，并起名为student,方便spring来查找
@Component("student")
public class Student {
    public void student(){
        System.out.println("111111");
    }
}

测试同上，在此略。

4.2@Value()和 @Autowired

@Value是给简单的属性注入值， @Autowired给复杂属性注入值。

给words注入值

public class Student {
    @Value("学生")
    private String words;
    public void student(){
        System.out.println(words);
    }
}

给复杂属性注入值，Autowired是按照类型注入的：

@Autowired
private User user;

通过注入之后，如果给User的属性已经注入了值，那么这里的user里面就有值了

4.3 @Autowired的扩展

@Autowired
@Qualifier("user")
private User user;

根据名字给复杂属性注入值，这样的好处是可以解决一个类有多个子类而找不到具体哪一个类的问题。而这两个注解有可以合为一个：

@Resource(name="user")

4.4@Component的优化

在spring2.5后为@Component添加了三个衍生的注解

@Repository 用于DAO层

@Service 用于service层

@Controller 用于表现层

4.5登录案例

Dao层

package com.dao.impl;

import com.dao.UserDao;
import com.entity.User;
import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public void login(User user) {
        if("zys".equals(user.getName())&&"20".equals(user.getAge())){
            System.out.println("登录成功");
        }else{
            System.out.println("登录失败");
        }
    }
}

package com.dao.impl;

import com.dao.UserDao;
import com.entity.User;
import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public void login(User user) {
        if("zys".equals(user.getName())&&"20".equals(user.getAge())){
            System.out.println("登录成功");
        }else{
            System.out.println("登录失败");
        }
    }
}

Service层

package com.service.impl;

import com.dao.UserDao;
import com.entity.User;
import com.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    UserDao dao;
    @Override
    public void login(User user) {
        dao.login(user);
    }
}

接口

package com.service;

import com.entity.User;

public interface UserService {
    void login(User user);
}

Controller层

package com.controller;

import com.entity.User;
import com.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    @Autowired
    UserService service;
    public void login(User user){
        service.login(user);
    }
}

测试类

package com.test;

import com.controller.UserController;
import com.entity.User;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

public class LoginTest {
    @Autowired
    UserController controller;
    @Test
    public void login(){
        User user=new User();
        user.setAge(20);
        user.setName("zys");
        controller.login(user);
    }
}

运行会出现如下错误：

技术图片

出现这个错误是因为测试类和Spring没有整合，如果想要在测试类中整合Spring需要将Spring和junit整合起来。整合步骤如下：

1、导入整合相关jar

技术图片

2、在测试类上配置如下内容完成整合

/使用spring的测试环境
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")

配置完成之后就可以测试了。

Spring总结

标签：size 文件 inject interface injection cto property alt private

原文地址：https://www.cnblogs.com/zys2019/p/11428105.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行