【Spring】（五）Spring 依赖注入以及使用注解实现IOC

最新推荐文章于 2022-07-31 00:56:28 发布

云祁

最新推荐文章于 2022-07-31 00:56:28 发布

阅读量1.1k

点赞数

本文链接：https://blog.csdn.net/BeiisBei/article/details/102907903

版权

---- Spring 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

文章目录

IOC创建对象的方式

平时创建对象的方式：

有参构造
无参构造

现在来看看在Spring中怎么处理这两种情况

1、在pojo包下创建实体类，代码如下：

public class User {

    private String name;
    private String sex;
    private int age;

    public User() {
        System.out.println("User的无参构造");
    }

    public User(String name) {
        System.out.println("User的有参构造");
        this.name = name;
    }

    public User(String name, int age) {
        System.out.println("User的有参构造2");
        this.name = name;
        this.age = age;
    }

    public User(String name, String sex, int age) {
        System.out.println("User的有参构造3");
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public void setName(String name) {
        System.out.println(name+":"+System.currentTimeMillis());
        this.name = name;
    }

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

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

2、在resources包下编写Spring的配置文件，代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<!--suppress SpringFacetInspection -->
<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">

    <!--
    Spring的配置文件
    bean 代表一个对象
    alias  别名
    import  导入一个其他资源
    -->

    <bean id="user" class="pojo.User">
    	<!--使用property属性时，相当于使用了setXXX()方法-->
    	<!--使用construct-arg属性时，相当于使用了有参构造方法中的赋值方法-->
        <property name="name" value="qinjiang"/>
    </bean>

    <!--使用构造器的参数下标进行赋值-->
    <bean id="user2" class="pojo.User">
        <constructor-arg index="0" value="kuangshen"/>
        <constructor-arg index="1" value="18"/>
    </bean>

    <!--通过名字进行赋值-->
    <bean id="user3" class="pojo.User">
        <constructor-arg name="name" value="kuangshen3"/>
        <constructor-arg name="age" value="3"/>
    </bean>

    <!--通过类型进行赋值-->
    <bean id="user4" class="pojo.User">
        <constructor-arg type="java.lang.String" value="kuangshen4"/>
        <constructor-arg type="java.lang.Integer" value="18"/>
        <constructor-arg type="java.lang.String" value="男"/>
    </bean>


</beans>

3、在test包下编写测试类，代码如下：

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

public class UserTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User)context.getBean("user");
        /*
        User user = new User();
        user.setName("qinjiang");
        */
        System.out.println(user.toString());
    }


    @Test
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user4");
        System.out.println(user);

    }

}

小结：

通过有参构造
- 通过下标
- 通过参数名【推荐】
- 通过参数类型
通过无参构造
- 默认会用无参构造

注意点：一定要有一个无参构造方法
事实上，也可以用其他方式来创建对象：可以选择查看怎么用工厂模式来创建

设置注入与构造注入的区别
在这里插入图片描述

Spring配置文件

bean

<!--bean讲解：
1.没有id，没有name，我们依旧可以获取这个对象，但是不建议使用、需要使用类的class对象获取；
    User bean = context.getBean(User.class);

2.id 就是对象的名字
3.class 就是要实例化的类
4.name就是别名
    有id的时候，name是别名 ， 没有id的时候，name就是对象的名字
    别名可以起多个
-->
<bean id="user" name="userTwo,user3" class="pojo.User">
    <property name="name" value="Spring"/>
</bean>

alias

<!--alias讲解：
 - name ： 就是bean对象的id
2,alias ： 对象的别名
-->
<alias name="user" alias="user4"/>

import

import一般在团队项目中会使用，每个人开发各自的beans.xml，最后用一个总的文件拼装起来。

<!--import讲解
作用：导入另外一个资源，把另外配置文件装进来
    classpath*: 他会去所有地方寻找你的文件。【效率低】
    classpath: 只会在classpath中寻找文件，找不到就报错；【建议使用】
    file：填写文件路径url【不建议使用】
    http：填写网络路径url【不建议使用】
-->
<import resource="classpath*:userBeans.xml"/>
<import resource="classpath:userBeans.xml"/>
<import resource="file:"/>
<import resource="http:"/>

依赖注入DI

DI（Dependency Injection）
依赖：指bean对象的创建依赖于Spring容器，bean对象所依赖的资源
注入：指bean对象所依赖的资源，由容器来设置和装配

构造器输入
- 有参构造
- 无参构造
setter注入
- 要求被注入的属性，必须有set方法，而且set方法的名字需要规范（set+属性名，且属性名的首字母要大写）

在这里插入图片描述

常量注入

<!--普通字段-->
<property name="name" value="小明"/>

Bean注入

<!--引用其他bean使用ref-->
<property name="address" ref="addr"/>

数组注入

<!--数组的注入-->
<property name="books">
<array>
    <value>西游记</value>
    <value>水浒传</value>
    <value>红楼梦</value>
    <value>三国演义</value>
</array>
</property>

List注入

<!--List注入-->
<property name="hobbys">
<list>
    <value>女孩</value>
    <value>代码</value>
    <value>电影</value>
    <value>音乐</value>
</list>
</property>

Map注入

<!--Map的注入-->
<!--
标签：entry

键：使用key

值:   使用value
-->
<property name="card">
<map>
    <entry key="IdCard" value="666666888888884444"/>
    <entry key="银行卡" value="111122223333444"/>
</map>
</property>

Set注入

<!--Set注入-->
<property name="games">
<set>
    <value>王者荣耀</value>
    <value>绝地求生</value>
    <value>LOL</value>
</set>
</property>

空值注入

<!--Null空值注入-->
<property name="girlFriend">
<null/>
</property>

Properties注入

<!--Properties注入-->
<property name="info">
<props>
    <prop key="学号">201932301</prop>
    <prop key="性别">男</prop>
    <prop key="姓名">小明</prop>
</props>
</property>

命名空间注入
p命名空间注入：属性的注入

<!--p：property属性，命名空间注入-->
<bean id="user1" class="pojo.User" p:name="abc" p:age="18"/>

c命名空间注入：构造器的注入

<!--c：constructor构造器：命名空间注入-->
<bean id="user2" class="pojo.User" c:name="abc" c:age="19"/>

使用注解实现IOC

1、注解方式将Bean的定义信息和Bean实现类结合在一起，Spring提供的注解有

@Component：实现Bean组件的定义
@Repository ：用于标注DAO类
@Service ：用于标注业务类
@Controller ：用于标注控制器类

@Repository("userDao") 
public class UserDaoImpl implements UserDao {
	…
}

等效于与在XML配置文件中编写

<bean id="userDao" 
class="dao.impl.UserDaoImpl" />

2、使用@Autowired注解实现Bean的自动装配，默认按类型匹配，可以使用@Qualifier指定Bean的名称

对类的成员变量进行标注

@Service("userService") 
public class UserServiceImpl implements UserService { 
        @Autowired
        @Qualifier("userDao")
        private UserDao dao; 
               …… 
}

也可以对方法的入参进行标注

@Service("userService") 
public class UserServiceImpl implements UserService { 
        private UserDao dao;
        @Autowired
        public void setDao((@Qualifier("userDao") UserDao dao) {
                 this.dao = dao;
        } 
  	…… 
}

3、使用注解信息启动Spring容器

<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/context
    http://www.springframework.org/schema/context/spring-context-3.2.xsd">
    <!-- 扫描包中注解标注的类 -->
    <context:component-scan base-package="service,dao" />
</beans>

4、使用Java标准注解完成装配
使用@Resource注解实现组件装配，默认按名称匹配

为dao属性注入名为userDao的Bean

@Service("userService") 
public class UserServiceImpl implements UserService { 
	@Resource(name = "userDao")
	private UserDao dao; 
	…… 
}

查找名为dao的Bean，并注入给dao属性

@Service("userService") 
public class UserServiceImpl implements UserService { 
	@Resource
	private UserDao dao; 
	…… 
}

代码实例

下面我用一个小项目完整的展示Spring使用注解实现IOC

1、User实体类

package userTest.entity;

/**
 * @author：
 * @date：2019/11/4
 * @aim：User实体类
 */

public class User {
    private String name;
    private String pwd;

    public User(){}

    public User(String name, String pwd) {
        this.name = name;
        this.pwd = pwd;
    }

    public String getName() {
        return name;
    }

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

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

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

2、Dao层

package userTest.dao;

import org.springframework.stereotype.Component;
import userTest.entity.User;

/**
 * @author：
 * @date：2019/11/4
 * @aim：
 */
@Component("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public boolean addUser(User user) {
        System.out.println("插入一条用户信息");
        return true;
    }
}

3、Service层

package userTest.service;

import org.springframework.stereotype.Service;
import userTest.dao.UserDao;
import userTest.entity.User;

import javax.annotation.Resource;

/**
 * @author：
 * @date：2019/11/4
 * @aim：
 */
@Service("userService")
public class UserServiceImpl implements UserService {

    //@Autowired
    //@Qualifier("userDao")   //两种注入方式
    @Resource(name = "userDao")
    private UserDao dao;

    public UserDao getDao() {
        return dao;
    }

    public void setDao(UserDao dao) {
        this.dao = dao;
    }

    @Override
    public boolean add(User user) {
        boolean flag=dao.addUser(user);
        return flag;
    }
}

4、增强类

package userTest.aop;


import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import userTest.service.UserService;
import java.util.Arrays;

/**
 * @author：
 * @date：2019/11/4
 * @aim：通知类，并在通知类上添加注解，描述那些切入点应该执行哪种增强处理
 */

@Controller("userAop")
@Aspect
public class UserServiceLogAop {
    Logger log= Logger.getLogger(userTest.aop.UserServiceLogAop.class);
    @Autowired
    @Qualifier("userService")
    private UserService service;

    public UserService getService() {
        return service;
    }

    public void setService(UserService service) {
        this.service = service;
    }

    @Pointcut("execution(public boolean add(userTest.entity.User))")
    public void pointcut(){}

    @Before("pointcut()")
    public void beforeAdd(JoinPoint jp){
        log.info("调用"+jp.getTarget()+"的"+jp.getSignature()+"之前，参数为:"+ Arrays.toString(jp.getArgs()));
    }

    @AfterReturning(pointcut = "pointcut()",returning = "result")
    public void afterAdd(JoinPoint jp, Object result){
        log.info("调用"+jp.getTarget()+"的"+jp.getSignature()+"之后,返回值为："+result);
    }

    @After("pointcut()")
    public void finalTest(JoinPoint jp){
        log.info(jp.getTarget()+"的"+jp.getSignature()+"方法执行结束");
    }
}

5、配置文件

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       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/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context-3.2.xsd">

    <!-- 扫描包中注解标注的类 -->
    <context:component-scan base-package="userTest" />

    <!--启用对于@AspectJ注解的支持-->
    <aop:aspectj-autoproxy />

    <!--使用p命名空间注入直接量-->
    <bean id="user" class="userTest.entity.User"
          p:name="Uzi" p:pwd="123456"/>

    <!--使用构造注入-->
    <bean id="user1" class="userTest.entity.User">
        <constructor-arg index="0">
            <value>TheShy</value>
        </constructor-arg>
        <constructor-arg name="pwd" >
            <value>123456</value>
        </constructor-arg>
    </bean>
</beans>

6、测试类

package userTest.service;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import userTest.entity.User;


public class UserServiceImplTest {

    @Test
    public void add() {
        ApplicationContext context=new ClassPathXmlApplicationContext("ApplicationContext3.xml");
        UserService userService=(UserService)context.getBean("userService");
        User user= (User) context.getBean("user");
        User user1= (User) context.getBean("user1");
        userService.add(user);
        userService.add(user1);
    }
}

7、结果

[INFO ] 2019-11-05 12:28:44,771 method:userTest.aop.UserServiceLogAop.beforeAdd(UserServiceLogAop.java:42)
调用userTest.service.UserServiceImpl@3c9754d8的boolean userTest.service.UserService.add(User)之前，参数为:[User{name='Uzi', pwd='123456'}]
插入一条用户信息
[INFO ] 2019-11-05 12:28:44,772 method:userTest.aop.UserServiceLogAop.finalTest(UserServiceLogAop.java:52)
userTest.service.UserServiceImpl@3c9754d8的boolean userTest.service.UserService.add(User)方法执行结束
[INFO ] 2019-11-05 12:28:44,773 method:userTest.aop.UserServiceLogAop.afterAdd(UserServiceLogAop.java:47)
调用userTest.service.UserServiceImpl@3c9754d8的boolean userTest.service.UserService.add(User)之后,返回值为：true
[INFO ] 2019-11-05 12:28:44,773 method:userTest.aop.UserServiceLogAop.beforeAdd(UserServiceLogAop.java:42)
调用userTest.service.UserServiceImpl@3c9754d8的boolean userTest.service.UserService.add(User)之前，参数为:[User{name='TheShy', pwd='123456'}]
插入一条用户信息
[INFO ] 2019-11-05 12:28:44,773 method:userTest.aop.UserServiceLogAop.finalTest(UserServiceLogAop.java:52)
userTest.service.UserServiceImpl@3c9754d8的boolean userTest.service.UserService.add(User)方法执行结束
[INFO ] 2019-11-05 12:28:44,773 method:userTest.aop.UserServiceLogAop.afterAdd(UserServiceLogAop.java:47)
调用userTest.service.UserServiceImpl@3c9754d8的boolean userTest.service.UserService.add(User)之后,返回值为：true

云祁

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Spring】（五）Spring 依赖注入以及使用注解实现IOC

文章目录IOC创建对象的方式Spring配置文件依赖注入DIIOC创建对象的方式平时创建对象的方式：有参构造无参构造现在来看看在Spring中怎么处理这两种情况1、在pojo包下创建实体类，代码如下：public class User { private String name; private String sex; private int age;...
复制链接

扫一扫

专栏目录