spring框架 多种注入方法+注释实现IOC AOP

最新推荐文章于 2020-04-15 23:01:26 发布
最新推荐文章于 2020-04-15 23:01:26 发布
阅读量154 收藏
点赞数

一，多种方式实现依赖注入
1.构造注入
构造注入是一种高内聚的体现，特别是针对有些属性需要在对象在创建时候赋值，且后续不允许修改（不提供setter方法）

<bean id="demo3" class="com.bdqn.cn.Demo">
        <constructor-arg><value type="java.lang.String">哈辛</value></constructor-arg>
        <constructor-arg><value type="int">3</value></constructor-arg>
    </bean>

2.设值注入：通过setter访问器注入数据。
设值注入的优劣势：设值注入使用灵活，但时效性不足，并且大量的setter访问器增加了类的复杂性。

 <bean id="author" class="com.bdqn.cn.Author">
        <property name="name" value="夏洛特"/>
        <property name="age" value="31"/>
        <property name="sex" value="女"/>
    </bean>


    <bean id="book" class="com.bdqn.cn.Book">
        <property name="name" value="简爱"/>
        <property name="author" ref="author"/>
    </bean>

3.p名称空间的使用

spring2.5以后，为了简化setter方法属性注入，引用p名称空间的概念，可以将 子元素，简化为元素属性配置 ！！
使用p命名空间必须导入 xmlns:p=“http://www.springframework.org/schema/p”

<bean id="user" class="entity.User" p:id="1" p:password="123" p:username="zhangsan"/>

二,处理不同类型的数据：特殊字符串处理
JavaBean
List
Array
Set
Map
Properties
空字符串
null值

实体类 ：TestEntity

package com.bdqn.cn;

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

public class TestEntity {
    private String specialCharacter1; // 特殊字符值1
    private String specialCharacter2; // 特殊字符值2
    private User innerBean; // JavaBean类型
    private List<String> list; // List类型
    private String[] array; // 数组类型
    private Set<String> set; // Set类型
    private Map<String, String> map; // Map类型
    private Properties props; // Properties类型
    private String emptyValue; // 注入空字符串值
    private String nullValue = "init value"; // 注入null值

    public void setSpecialCharacter1(String specialCharacter1) {
        this.specialCharacter1 = specialCharacter1;
    }

    public void setSpecialCharacter2(String specialCharacter2) {
        this.specialCharacter2 = specialCharacter2;
    }

    public void setInnerBean(User user) {
        this.innerBean = user;
    }

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

    public void setArray(String[] array) {
        this.array = array;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

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

    public void setProps(Properties props) {
        this.props = props;
    }

    public void setEmptyValue(String emptyValue) {
        this.emptyValue = emptyValue;
    }

    public void setNullValue(String nullValue) {
        this.nullValue = nullValue;
    }

    public void showValue() {
        System.out.println("特殊字符1：" + this.specialCharacter1);
        System.out.println("特殊字符2：" + this.specialCharacter2);
        System.out.println("内部Bean：" + this.innerBean.getUsername());
        System.out.println("List属性：" + this.list);
        System.out.println("数组属性[0]：" + this.array[0]);
        System.out.println("Set属性：" + this.set);
        System.out.println("Map属性：" + this.map);
        System.out.println("Properties属性：" + this.props);
        System.out.println("注入空字符串：[" + this.emptyValue + "]");
        System.out.println("注入null值：" + this.nullValue);
    }
}

spring配置文件：spring_config.xml

<bean id="entity" class="com.bdqn.cn.TestEntity">
        <!--使用<![CDATA[]]>标记处理XML特殊字符-->
        <property name="specialCharacter1">
            <value><![CDATA[P&G]]]></value>
        </property>
        <!--把XML特殊字符替换为实体引用-->
        <property name="specialCharacter2">
            <value>P&amp;G</value>
        </property>

        <!--定义内部Bean-->
        <property name="innerBean">
            <bean class="com.bdqn.cn.User">
                <property name="username">
                    <value>Mr.Inner</value>
                </property>
            </bean>

        </property>
        <!--List类型-->
        <property name="list">
            <list>
                <!--定义List中的元素-->
                <value>足球</value>
                <value>篮球</value>
            </list>
        </property>

        <!--注入数组类型-->
        <property name="array">
            <list>
                <value>足球</value>
                <value>篮球 </value>
            </list>
        </property>

        <!--Set类型-->
        <property name="set">
            <set>
                <value>足球</value>
                <value>篮球 </value>
            </set>
        </property>

        <!--Map类型-->
        <property name="map">
            <map>
                <!--定义Map中的键值对-->
                <entry>
                    <key>
                        <value>football</value>
                    </key>
                    <value>足球</value>
                </entry>
                <entry>
                    <key>
                        <value>basketball</value>
                    </key>
                    <value>篮球</value>
                </entry>
            </map>
        </property>
        <!--注入Properties类型-->
        <property name="props">
            <props>
                <!--定义Properties中的键值对-->
                <prop key="football">足球</prop>
                <prop key="basketball">篮球</prop>
            </props>
        </property>
        <!--注入空字符串值-->
        <property name="emptyValue">
            <value></value>
        </property>
        <!--注入null值-->
        <property name="nullValue">
            <null/>
        </property>
    </bean>

测试类

  @Test
    public void testEntity(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring_config.xml");
        TestEntity testEntity = (TestEntity)context.getBean("entity");
        System.out.println(testEntity.toString());
    }
}

三 ，使用注解实现IoC的配置
之前我们配置IOC(控制反转)都是在xml中配置，现在通过注解配置IOC会减少很多代码

使用注解实现Bean组件的定义:

（1）@Component：该注解与等效。

（2）@Respository：该注解用于标注Dao类。

（3）@Service：该注解用于标注业务逻辑类。

（4）@Controller：该注解用于标注控制器类。

使用注解实现Bean组件的装配：

（1）@Autowired：该注解用于注入所依赖的对象。

（2）@Autowired 采用按类型匹配的方式为属性自动装配合适的依赖对象，即容器会查找和属性类型相匹配的Bean组件，并自动为属性注入。

（3）@Qualifier：该注解用于指定所需Bean的名字。

加载注解定义的Bean：

首先在spring配置文件中添加对context命名空间的声明，然后使用context命名空间下的component-scan标签扫描注解标注的类，base-package 属性指定了需要扫描的基准包。

实现IOC注解
配置 spring_zhujie.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:aop="http://www.springframework.org/schema/aop"
       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.xsd">
  <!--多个包逗号隔开-->
    <context:component-scan base-package="com.bdqn.dao,com.bdqn.service"/>
</beans>

数据访问层：userDaoImpl.java

package com.bdqn.dao;

public interface UserDao {
    //通过用户名得到密码
    public String getPwd(String name);
}

业务逻辑层：userServiceImpl.java

package com.bdqn.dao.daoimpl;

import com.bdqn.dao.UserDao;
import org.springframework.stereotype.Repository:

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public String getPwd(String name) {
        //忽略数据库操作
        return "admin";
    }
}

业务逻辑层：userServiceImpl.java

package com.bdqn.service.serviceimpl;

import com.bdqn.dao.UserDao;
import com.bdqn.service.UserService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service("userService")
public class UserServiceImpl implements UserService {
   // @Autowired
    	//@Qualifier("userDao")
    	private UserDao userDao;
    	@Override
    	public String getPwd(String name) {
       		 return userDao.getPwd(name);
    }
}

测试类

  @Test
    public void testzhujie(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring_zhujie.xml");
         UserService userService= (UserService) context.getBean("userService");
         String pwd= userService.getPwd("admin");
        System.out.println(pwd);
    }

四 、使用注解定义切面

使用注解实现一个简单的AOP切面：

spring配置文件：springConfig.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:aop="http://www.springframework.org/schema/aop"
       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">
     <aop:aspectj-autoproxy/>
    <bean id="target" class="com.bdqn.aop.Target"></bean>
    <bean id="adviceTarget" class="com.bdqn.aop.AdviceTarget"></bean>

</beans>

目标类 Taget .Java

package com.bdqn.aop;

import org.springframework.stereotype.Component;

//目标类

@Component("target")
public class Target {
    public String show(String name) {
        System.out.println("这是目标方法。。。。");
        return "hello"+name;
    }
}

目标增强类AdviceTaget.java

package com.bdqn.aop;

import org.aopalliance.intercept.Joinpoint;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

/**
 * Created by 18054 on 2018/9/25.
 */
//增强类
    @Aspect
public class AdviceTarget {

    @Before("execution(* com.bdqn.aop.*.*(..))")
    public void before(JoinPoint jp){
        System.out.println("参数3"+jp.getArgs()+",方法名"+jp.getSignature()+",目标对象："+jp.getTarget());
    }
    @After("execution(* com.bdqn.aop.*.*(..))")
    public void after(JoinPoint jp){
        System.out.println("这是后置增强");
    }
    @AfterReturning(value = "execution(* com.bdqn.aop.*.*(..))",returning = "value")
    public void afterReturn(JoinPoint jp,String value ){
        System.out.println("后置带返回值"+value);
    }
    @AfterThrowing(value = "execution(* com.bdqn.aop.*.*(..))", throwing = "ex")
    public void afterException(JoinPoint jp,Exception ex){
        System.out.println("后置带异常"+ex);
    }
    @Around("execution(* com.bdqn.aop.*.*(..))")
    public void around(ProceedingJoinPoint jp){
        String str= (String) jp.getArgs()[0];
        if(str.equals("admin")){
            //有权限，可以访问目标方法
            try {
                String value=  jp.proceed().toString();
                System.out.println("返回值"+value);
            } catch (Throwable throwable) {
                throwable.printStackTrace();
            }
        }else {
            //无权限
            System.out.println("没有权限");
            //跳转到登陆页面
        }
    }

}

测试类

  @Test
    public void testTarget() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring_aop.xml");
        Target target = (Target) context.getBean("target");
        System.out.println(target);
    }```
haoxin1805487180
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring框架
Albert_yin的博客
04-11 234
Spring框架介绍 spring是一个轻量的企业级框架，提供了ioc容器，aop实现，dao/orm支持，web集成等功能，可以将一个数据框架和一个展现框架协调管理。使现有的java ee技术更易用 spring core是框架的最基础部分，提供了ioc特性；spring aop是基于spring core的符合规范的面向切面编程的实现。 Ioc/DI inversion of control控...
Spring框架知识点总结
qq_42962396的博客
10-10 741
简述：Spring 框架（简称Spring）是 SpringSource 出品的一个用于简化 Java企业级应用开发开源的应用程序框架。它提供了开发一个结构良好的、可维护和易于测试的应用所需的基础设施，当使用Spring框架时，开发者只需要专注于编写应用的业务逻辑。从而提供开发者的生产效益。你可以使用Spring框架开发独立的Java应用程序、Web应用程序、Applet 或任何其他类型的Java...
【Spring】（五）Spring 依赖注入以及使用注解实现IOC
云祁QI
11-05 1158
文章目录IOC创建对象的方式Spring配置文件依赖注入DI IOC创建对象的方式 平时创建对象的方式： 有参构造 无参构造 现在来看看在Spring中怎么处理这两种情况 1、在pojo包下创建实体类，代码如下： public class User { private String name; private String sex; private int age; ...
spring框架
zhanghuanhuan666的博客
09-28 114
一. 1.构造注入 构造注入是一种高内聚的体现，特别是针对有些属性需要在对象在创建时候赋值，且后续不允许修改（不提供setter方法） 2.设值注入：通过setter访问器注入数据。 设值注入的优劣势：设值注入使用灵活，但时效性不足，并且大量的setter访问器增加了类的复杂性。 3.p名称空间的使用 spring2.5以后，为了简化setter方法属性注入，引用p名称空间的概念，可以将 子元素，...
Spring-02 Spring IoC和AOP使用扩展
weixin_43094361的博客
02-14 271
一、多种方式实现依赖注入 1、设值注入 通过setter访问器实现了对属性的赋值，这种方式称为设值注入。 2、构造注入 构造方法参数类型为对象 UserServiceImpl.java public class UserServiceImpl implements UserService { private UserDao userDao; //无参构造 public UserS...
myBatis 一对多关联------------二级缓存
haoxin1805487180的博客
09-10 630
2.1、提出需求 　　根据classId查询对应的班级信息,包括学生,老师 2.2、创建表和数据 　　在上面的一对一关联查询演示中，我们已经创建了班级表和教师表，因此这里再创建一张学生表 CREATE TABLE student( s_id INT PRIMARY KEY AUTO_INCREMENT, s_name VARCHAR(20), class_id ...
Spring中依赖注入的四种方式
weixin_33756418的博客
11-21 1370
转载自：http://blog.163.com/qqabc20082006@126/blog/static/2292852520091125112112902/在Spring容器中为一个bean配置依赖注入有三种方式：· 使用属性的setter方法注入 这是最常用的方式；· 使用构造器注入；· 使用Filed注入（用于注解方式）.使用属性的setter方法注入首先要配置被注...
Bean注入方式3：使用注解装配属性（@Resource）
一起喝咖啡吧
04-04 255
bean的注入方式有3种: 第一种:使用构造器注入第二钟:使用属性setter方法注入第三种:使用Field注入（用于注解方式）下面我们使用注解的方式完成bean的注入在java代码中使用@Autowired或@Resource注解方式进行装配，这两个注解的区别是：@Autowired 默认按类型装配，@Resource默认按名称装配，当找不到与名称匹配的bean才会按类型装配。 @Autow...
mybatis整合Spring的步骤
haoxin1805487180的博客
10-10 1284
一：添加jar包 mybatis: mybatis-3.2.0.jar mybatis-spring-1.1.1.jar // 整合spring的关键jar包 log4j-1.2.17.jar Spring: spring-aop-3.2.0.RELEASE.jar spring-beans-3.2.0.RELEASE.jar s...
(精简)Spring框架的IoC(替代工厂类实现方法)和AOP(定义规则，约定大于配置)
u014078192的专栏
05-08 1315
Spring的核心框架主要包含两个技术，分别用来处理工厂类，以及事务处理和连接管理的。 两大核心概念 1）  IoC：控制反转，在现在的开发中，如果想建立对象并设置属性，是需要先new对象，再通过setter或构造方法设置属性。而使用Spring的IoC后，则是先通过配置声明属性的值或关系，再通过Spring框架建立对象，建立好的对象中就自动设置好了配置的属性。此功能可以替代工厂类。在IoC
Mybatis笔记总结
weixin_42847626的博客
11-02 94
1.mybatis 中 foreach collection的三种用法 https://blog.csdn.net/haoxin1805487180/article/details/82778991 2.MySQL批量插入、批量更新及批量删除语句 https://blog.csdn.net/u014252478/article/details/91386289 ...
AOP面向切面编程
haoxin1805487180的博客
09-26 174
1AOP概述 AOP(Aspect-Oriented Programming，面向切面编程)：是一种新的方法论，是对传统 OOP(Object-Oriented Programming，面向对象编程)的补充。两种编程思想。是对面向对象编程的一种补充。 面向切面编程：是指在程序运行期间将某段代码，动态的切入到某个类的指定方法的指定位置的这种编程思想叫做面向切面编程。 AOP编程操作的主要对象是切面(...
spring 从入门到总结
luolinghong_csdn的博客
10-31 921
菜鸟教程 http://www.runoob.com/w3cnote/basic-knowledge-summary-of-spring.html http://qilixiang012.iteye.com/blog/2091295 框架 Spring 学习版本: 4.3.0 框架认识 框架学起来比较简单 但也有难的地方,难是难在底层原理   用了框架之后,写代码就非常简单,
那些年我们一起着迷的Spring:初始化与注入方式（三）
eluanshi12的博客
04-19 1836
参考慕课网视屏和慕课网上笔记 专题一：IOC —- Spring入门 spring学习手册记录本 参考spring面试题及答案解析（7） Spring的bean配置 在IOC容器中将所有的控制对象称作bean，（spring中把所有对象都称之为bean） Spring对于bean的使用有两种方式： 基于.xml的文件配置（如spring-ioc.xml） 注解（如 Compone...
foreach (在实现 mybatis in 语句查询时特别有用)
热门推荐
haoxin1805487180的博客
09-19 2万+
foreach可以遍历所有的可以迭代的对象，集合，数组，map等等。 属性：index 当迭代对象是数组，列表时，表示的是当前迭代的次数 当对象是map之类的时候，表示的是当前map的key。 item 当迭代对象是数组，列表时，表示的是当前迭代的元素。 当对象是map之类的时候，表示的是当前map的value值。 collection 当前不要遍历的对象 separator 遍历完一次后，在...
Spring IOC介绍与4种注入方式
聚沙成塔
10-16 836
Spring IOC介绍 spring的核心思想是IOC和AOP，IOC-控制反转，是一个重要的面向对象编程的法则来消减计算机程序的耦合问题，控制反转一般分为两种类型，依赖注入和依赖查找，依赖什么？为什么需要依赖？注入什么？控制什么？依赖注入和控制反转是一样的概念吗？接触新的知识，今天主要来简单的介绍一下在spring IOC中依赖注入的方法。 依赖注入和控制反转，目的是为了使类与类之间解耦合...
通过注解的方式注入依赖对象
永无止境
04-15 1549
文章目录@Autowired：注入依赖对象@Resource：注入依赖对象@Qualifier：限定符@Primary：设置为主要候选者泛型注入参考 @Autowired：注入依赖对象 实现依赖注入，spring容器会对bean中所有字段、方法进行遍历，标注有@Autowired注解的，都会进行注入 @Autowired标注在字段上面：假定字段类型为一个自定义的普通的类型，候选者查找过程如下 @...
为业务层添加声明式事务
haoxin1805487180的博客
10-17 417
可以采用MyBatis控制事务 事务应该在业务逻辑层控制 硬编码方式，代码繁琐，且破坏分层，代码不易维护 可以采用AOP的方式实现 Spring提供了声明式事务支持 propagation：事务传播机制 REQUIRED（默认值） REQUIRES_NEW 、MANDATORY、NESTED SUPPORTS NOT_SUPPORTED、NEVER 1.propagation:事务传播机制。 （1...
第一章 初始MyBatis
haoxin1805487180的博客
09-07 412
第一章 初始MyBatis 一、Mybatis介绍 　　 　　MyBatis是一个支持普通SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装。MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数...
spring框架是为了解决什么问题？ioc和aop是什么？
最新发布
05-19
Spring框架解决这些问题的方法是通过提供一组功能强大的工具来简化企业应用程序的开发和维护。其中最重要的是控制反转（IoC）和面向切面编程（AOP）。 IoC是一种编程模式，它将对象的创建和管理委托给Spring框架。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值