Spring框架入门

最新推荐文章于 2024-06-17 23:55:25 发布
最新推荐文章于 2024-06-17 23:55:25 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： Spring 文章标签： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38982845/article/details/82851834
版权

一.模块划分

二.Spring的ICO实现的核心技术

三.ICO的模拟实现(重点)

       1.工厂实例化对象

                工厂的分类:简单工厂;工厂方法;抽象工厂(通用的工厂方法)

ICO工厂产生对象的方法:    

       2.XML解析

解析方式为DOM4J的解析方式,需要导入相应的架包

       3.反射

通过方式得到实体类的对象,然后通过method的invoke方法给属性赋值,具体的实现工厂为:

/**
 * 模拟ioc实例化对象的思路
 *   1.xml解析
 *   2.对象实例化
 *   3.对外提供getObj方法
 *      根据对象名获取value
 *   4.给属性赋值(依赖注入|装配)
 *      反射实现 set  方法赋值操作
 *
 */
public class SxtFactory_07 implements SxtFactory {

    private Map<String,Object> map=new HashMap<String,Object>();

    private List<SxtBean> beans =new ArrayList<SxtBean>();

    public SxtFactory_07(String fileName) {
        this.parseXml(fileName);
        this.instanceBean();
        this.setSxtProperty();
    }

    /**
     * 给属性赋值
     */
    private void setSxtProperty() {
        try {
            if(beans.size()>0){
                for(SxtBean sxtBean:beans){
                    // 获取属性集合
                    List<SxtProperty> properties=sxtBean.getProperties();
                    if(null !=properties && properties.size()>0){
                        for(SxtProperty property:properties){
                            String id=property.getId();
                            // 首字母大写
                            id=id.toUpperCase().charAt(0)+id.substring(1);
                            String ref=property.getRef();
                            Class clazz=map.get(sxtBean.getId()).getClass();
                            Method method= clazz.getDeclaredMethod("set"+id,map.get(ref).getClass());
                            method.invoke(map.get(sxtBean.getId()),map.get(ref));
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void instanceBean() {
        try {
            if(beans.size()>0){
                for(SxtBean sxtBean:beans){
                    map.put(sxtBean.getId(),Class.forName(sxtBean.getClazz()).newInstance());
                }
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * xml 解析
     * @param fileName
     */
    private void parseXml(String fileName) {
        /**
         * xml 解析
         */
        URL url= this.getClass().getClassLoader().getResource(fileName);
        if(null !=url){
            SAXReader saxReader=new SAXReader();
            try {
                Document document= saxReader.read(url);
                XPath xPath= document.createXPath("beans/bean");
                List<Element> elements= xPath.selectNodes(document);


                if(null!=elements && elements.size()>0){
                    for(Element element:elements){
                        xPath=document.createXPath("property");
                        // 匹配当前的元素
                        List<Element> subElements= xPath.selectNodes(element);
                        List<SxtProperty> properties=null;
                        SxtBean sxtBean= new SxtBean(element.attributeValue("id"),element.attributeValue("class"));
                        if(null !=subElements && subElements.size()>0){
                            properties=new ArrayList<SxtProperty>();
                            for(Element subElement:subElements){
                                SxtProperty property=new SxtProperty(subElement.attributeValue("id"),subElement.attributeValue("ref"));
                               properties.add(property);
                            }
                        sxtBean.setProperties(properties);
                        }


                       beans.add(sxtBean);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }else{
            System.out.println("文件未找到!!!");
        }
    }

    @Override
    public Object getObj(String name) {
        return map.get(name);
    }
}

spring.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <bean id="userService" class="com.shsxt.service.UserService">
        <!--
          id:属性名称
          ref:实例化的对象的id 唯一标识
        -->
        <property id="userDao" ref="userDao"></property>
        <property id="testService" ref="testService"></property>

       <!-- <property id="userDao" ref="userDao"></property>
        <property id="userDao" ref="userDao"></property>
        <property id="userDao" ref="userDao"></property>-->

    </bean>

    <bean id="accountService" class="com.shsxt.service.AccountService">
       <!-- <property id="userDao" ></property>-->
    </bean>
    <bean id="userDao" class="com.shsxt.dao.UserDao"></bean>
    <bean id="testService" class="com.shsxt.service.TestService"></bean>
</beans>

四.IOC 扫描器模拟

1.获取扫描包的范围
                  com.shsxt02(直接给的的方式)
            2.获取指定包以及子包下的所有的class 文件(不考虑jar包)
                  C:\\java\workspace21\\ioc01\\src\main\\java\\com\\shsxt02\\dao\\UserDao.class
                  C:\\java\workspace21\\ioc01\\src\main\\java\\com\\shsxt02\\dao\\AccountDao.class
                   .....

/**
    * @Description:获取指定包以及子包下的所有的class 文件(不考虑jar包)
    * @Author: Mr Tong
    * @Date: 2018/9/26 21:48
    */
    public static void getAllClass(String pkg){
        // com/shsxt02
        URL url=Thread.currentThread().getContextClassLoader().getResource(replacePath(pkg));
        String basePath=url.getFile();
        String[] subFileStrs= new File(basePath).list();
        for(String str:subFileStrs){
            // 获取子目录地址
            String subFilePath=basePath+"/"+str;
            File subFile=new File(subFilePath);
            if(subFile.isDirectory()){
                getAllClass(pkg+"."+subFile.getName());
            }else{
                //System.out.println(basePath+"/"+subFile.getName());
                // com.shsxt02.controller.UserController
                // 存储包名-指定类的全路径
                clazzzz.add(pkg+"."+subFile.getName());
            }
        }


    }


            3.判断class 类级别上有没有标注指定注解
                   注解存在
                         实例化该对象:获取id 唯一标识

/**
    * @Description: 实例化对象的方法,
     * 判断class 类级别上有没有标注指定注解
     *     注解存在:
     *        实例化该对象:获取id 唯一标识
    * @Author: Mr Tong
    * @Date: 2018/9/26 21:47
    */
    private static void instanceBeans() {
        try {
            if(clazzzz.size()>0){
                for(String classStr:clazzzz){
                    classStr=classStr.replace(".class","");
                    SxtComponent sxtComponent=  Class.forName(classStr).getAnnotation(SxtComponent.class);
                    if(null !=sxtComponent){
                        Object obj=Class.forName(classStr.replace(".class","")).newInstance();
                        classStr= classStr.substring(classStr.lastIndexOf(".")+1);
                        String key=classStr.toLowerCase().charAt(0)+classStr.substring(1);
                        System.out.println(key);
                        map.put(key, obj);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

 4.依赖注入
                 * 获取map 中每个对象的 fields
                 * 获取字段级别的注解   SxtResource
                 * 调用field 的set方法实现注入

/**
     * 依赖注入
     * 获取map 中每个对象的 fields
     * 获取字段级别的注解   SxtResource
     * 调用field 的set方法实现注入
     */
    private static void execAutoWired() {
        try {
            if(null != map && !(map.isEmpty())){
                for(Map.Entry<String,Object> entry:map.entrySet()){
                    Class clazz = entry.getValue().getClass();
                    Field[] fields = clazz.getDeclaredFields();
                    System.out.println(fields + "~~~");
                    if(null != fields && fields.length>0){
                        for(Field field:fields){
                            //SxtComponent sxtComponent=  Class.forName(classStr).getAnnotation(SxtComponent.class);
                            SxtAutoWired sxtAutoWired = field.getAnnotation(SxtAutoWired.class);
                            System.out.println("sxtAutoWired");
                            if(null != sxtAutoWired){
                                field.setAccessible(true);
                                //field.set(entry.getValue(),map.get(sxtAutoWired.value()));
                            }
                        }
                    }
                }
                }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

五.依赖注入(装配)

  

六.作用域及生命周期

七.注解之bean的注入

对于 bean 的注入，除了使用 xml 配置以外，注解的配置简化开发的速度，使程序看上去更简洁。对于注解的解释， spring 对于注解有专门的解释器，对定义的注解进行解析，实现对应 bean 对象的注入， 反射技术实现。

1.加入 spring-aop jar 包 spring-aop-4.3.2.RELEASE.jar

2.Xml 配置: 加入 context 命名空间 和 xsd 地址

3. 添加<context:annotation-config/> 配置

<?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:annotation-config/>
</beans>

1.bean 的注入常用注解类型: 

 @Autowired 属性字段或 set 方法上
 @Resource 属性字段上或 set 方法上
区别: @Autowired 默认按 bean 的类型匹配 可以修改 按名称匹配 和@Qualifier 配合使用
         @Resource 默认按名称进行装配，名称可以通过 name 属性进行指定，如果没有指定 name 属性，当注解写在字段上时，默认取字段名进行匹配注入，如果注解写在 setter 方法上默认取属性名进行装配。当找不到与名称匹配的 bean时才按照类型进行装配。 但是需注意的是，如果 name 属性一旦指定，就只会按照名称进行装配。
          推荐使用@Resource 注解是属于 J2EE 的，减少了与 spring 的耦合。

2.Spring Ioc 容器自动扫描管理 bean

实际的开发中， bean 的数量非常多，采用手动配置 bean 的方式已无法满足生产需要， spring 这时候同样提供了扫描的方式，对扫描到的 bean 对象统一进行管理，简化开发配置，提高开发效率。

扫描指定的包:

<context:component-scan base-package="com.shsxt"/>

开发中建议(开发中的一种约定)

  1.  Dao 层:@Repository
  2. Service 层:@Service
  3. 视图控制层:@Controller
  4. 如果对于开发的类实在不明确到底属于哪个层，可以使用@Component 注解定义。@Resource的装配顺序：

  5. @Resource后面没有任何内容，默认通过name属性去匹配bean，找不到再按type去匹配指定了name或者type则根据指定的类型去匹配bean,指定了name和type则根据指定的name和type去匹配bean，任何一个不匹配都将报错


     



 

 

 


 


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

萌萌的PP
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring框架从入门到精通
cgblpx的博客
06-08 3万+
初识Spring框架 时代变迁 原始时代我们用一个jsp搞定一切，但如此开发大型项目时我们遇到了问题，前端美化的代码和后端的代码交织，代码中又有html、js、css样式，又有业务逻辑和数据库访问代码，杂乱不清晰，美工和开发打架。 于是mvc分层架构封建时代出现，把我们写代码的地方硬性分成3个地方，Model层封装数据，View视图层页面展现，Controller控制层访问转发。代码之间的耦合度降低。概念有了，需要实际干活的。于是随着mvc分层概念的深入人心，业界涌现出很多实现框架，最著名的莫过于strut
Spring学习笔记（一）Spring框架入门
weixin_72154059的博客
02-06 1532
1、 我们经常挂在口中的Spring指的是（Spring 框架）它是一个开源框架，有着活跃而庞大的社区。这就是它之所以能长久不衰的原因，Spring支持广泛的应用场景，它可以让Java企业级开发应用程序开更简单。2、Spring是由Rod Johnson组织和开发的一个分层的Java SE/EE一站式（full-stack）轻量级开源框架。它最为核心的理念是IoC（控制反转）和AOP（面向切面编程），其中，IoC是Spring的基础，它支撑着Spring对JavaBean的管理功能；
Spring框架的原理及应用详解（七）
凛鼕将至的博客
06-17 893
​ Spring框架是一个开源的、轻量级的Java应用开发框架，旨在为Java开发人员提供一个全面且高效的解决方案来构建企业级应用。它支持各种设计模式，并通过IoC（控制反转）和AOP（面向切面编程）等核心技术，极大地简化了应用程序的开发、管理和测试过程。 本文将跟随《​​​​​​​Spring框架的原理及应用详解（六）》的进度，继续介绍Spring框架。希望通过本系列文章的学习，您将能够更好地理解Spring框架的内部工作原理，掌握Spring框架的使用技巧，以及通过合理的设计完成最佳
Spring 框架入门介绍及IoC的三种注入方式
让优秀成为一种习惯！
08-16 2342
- 用Spring框架来实现全新的控制反转方法，让你的应用程序更加灵活和易于维护 - 创建一个基于Spring框架的控制反转教程，帮助开发人员更好地理解和运用这个设计模式 - 探索Spring框架中控制反转的潜在优势，包括减少模块之间的耦合、提升可测试性和可扩展性 - 设计一个创新的Spring应用程序，利用控制反转实现模块之间的松耦合关系 - 分析控制反转在Spring框架中的实际应用，包括依赖注入和依赖查找的使用场景
Java Web之Spring框架（入门）
qq_42109746的博客
03-27 1052
一、Spring概念 1.Spring是开源的轻量级框架。 2.Spring核心主要有两部分： （1）aop:面向切面编程，扩展功能不是修改源代码实现，而是通过配置文件。 （2）ioc:控制反转。（对象的创建不是通过new方法来实现，而是通过Spring配置创建类对象） 3.Spring是一站式框架，在Java EE三层结构中，每一层都提供不同的解决技术。 Web层：Spring...
spring框架入门到熟练
GuoCo的博客
03-25 2889
个人笔记，不足之处请指点，谢谢！ 官网:http://spring.io/ 文档:http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/ spring的概况 spring是一个开源框架，为了解决企业应用开发的复杂性而创建的，是一个轻量级的控制反转（IoC）和面向切面（AoP）的容器框架
Java--Spring入门
MinggeQingchun的博客
06-03 901
一、Spring简介 （一）简介 Spring 是于 2003 年兴起的一个轻量级的 Java 开发框架，它是为了解决企业应用开发的复杂性而创建的 Spring 的核心是控制反转（IoC）和面向切面编程（AOP）。Spring 是可以在 Java SE/EE 中使用的轻量级开源框架 简而言之：Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架 Spring 的主要作用就是为代码“解耦”，降低代码间的耦合度 Spring官网：https://spring.io/ .
Spring快速入门超详细讲解
南 阳 的博客
07-02 3953
在Spring框架规范中，所有由spring管理的对象都称之为Bean对象。Spring提供了以下多个注解，这些注解可以直接标注在java类上，将它们定义成Spring Bean。注解说明@Component该注解用于描述Spring中的Bean，它是一个泛化的概念，仅仅标识容器中的一 个组件（Bean），并且可以作用在任何层次，例如Service层、Dao层等，使用时只需将该注解标注在相应的类上即可。
Spring框架入门（一）
热门推荐
zxiang248的专栏
06-29 3万+
Spring 框架概述 1.1. 什么是Spring Spring是分层的JavaSE/EE full-stack(一站式) 轻量级开源框架 分层： 来自JavaEE体系结构 （客户端层、 web层、业务层、持久层 ） 服务器端三层结构 （web层、业务层、持久层） Servlet + JSP —- web层技术 —- Struts2框架 JDBC 接口 —-
spring框架入门详解
vv___的博客
11-14 1373
本文目的： 1 建立spring的依赖构建 2 建立依赖构建的话，就可以使用spring核心功能 3 依赖注入的概念 spring框架概念 核心支持依赖注入，事务管理，Web应用程序，数据访问，消息传递，测试等等。 介绍 Spring框架为现代基于Java的企业应用程序提供了全面的编程和配置模型 - 在任何类型的部署平台上。Spring的一个关键要素是应用程序级别的基础架
Spring框架入门程序
04-12
定义一个接口IKnow，里面包含know方法；定义该接口的实现类IKnowImpl，在know方法里输出“ I know everything"; 基于Spring框架配置该类的对象(bean)，并创建容器获取bean调用know方法，输出结果。
Spring框架入门资料
05-30
本入门资料旨在帮助初学者快速掌握Spring框架的基础知识和实践技巧。 首先，"Spring讲义-IDEA版.doc"和"Spring讲义.doc"是两份详细的教程文档，它们通常会涵盖Spring框架的基本概念、核心组件如IoC容器、AOP、Bean...
2024年全球资产管理报告：AI与下一轮转型浪潮-BCG.pdf
08-02
2024年全球资产管理报告：AI与下一轮转型浪潮-BCG.pdf
电子书：探索人工智能在 OSINT 中的作用中文版.pdf
08-02
电子书：探索人工智能在 OSINT 中的作用中文版.pdf
基于Springboot的线上历史馆藏系统（有报告） Javaee项目，springboot项目
最新发布
08-02
资源详情：https://blog.csdn.net/2302_78191516/article/details/140881816
Spring框架入门详解
本书主要介绍了Spring框架，它是Java EE（现称为Java SE/EE）开发中的一个核心组件，提供了丰富的功能，旨在简化企业级应用的开发。Spring框架以其依赖注入（Dependency Injection，DI）和控制反转（Inversion of ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值