Spring初见

最新推荐文章于 2024-09-05 15:45:17 发布
最新推荐文章于 2024-09-05 15:45:17 发布
阅读量100 收藏
点赞数
分类专栏： Spring 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peng_miao_no1/article/details/120619934
版权

一、Spring框架

1、Spring是一个由Java语言开发的框架。

2、Spring在项目开发时主要提供两种服务：IOC服务/AOP服务

3、目前为止，所有的Java项目中都会使用Spring框架

二、IOC服务

1、IOC服务，意为“控制反转”

2、IOC服务中，可以由Spring容器为开发人员提供项目运行时需要的对象

3、IOC服务简单来说，就是由Spring容器负责帮你创建需要的对象

三、Spring容器对象：

1、容器：存储对象的载体。一般指的是List,Set,Map,数组

2、容器对象：如果某个对象中的属性是集合，且这个集合用于存储其他的对象

四、IOC最终认识

  • 之前在开发时，需要某个对象时，需要自己来负责创建；IOC服务中，当你需要某个对象时，可以向Spring容器对象索要。

五、为什么需要由Spring容器提供需要的对象

  • 在开发时，某些对象的获得相对困难且繁琐，例如jdbc中的PreparedStatment对象和MyBatis中的SqlSession对象。

    • 1、Class.forName(Driver接口);

    • 2、Connection con = DriverManager.getConnection();

    • 3、PreparedStatment ps = con.preparedStatment();

    • 1、InputStream in = Resources.getResourceAsStream("mybatis.xml");-

    • 2、 SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

    • 3、SqlSession sqlSession = factory.openSession(true);

public class Dept {
    private Integer deptNo;
    private String dname;
    private String loc;
​
    @Override
    public String toString() {
        return "Dept{" +
                "deptNo=" + deptNo +
                ", dname='" + dname + '\'' +
                ", loc='" + loc + '\'' +
                '}';
    }
​
    public Integer getDeptNo() {
        return deptNo;
    }
​
    public void setDeptNo(Integer deptNo) {
        this.deptNo = deptNo;
    }
​
    public String getDname() {
        return dname;
    }
​
    public void setDname(String dname) {
        this.dname = dname;
    }
​
    public String getLoc() {
        return loc;
    }
​
    public void setLoc(String loc) {
        this.loc = loc;
    }
}
//====================================================
public class Emp {
    private Integer empNo;
    private String ename;
​
    @Override
    public String toString() {
        return "Emp{" +
                "empNo=" + empNo +
                ", ename='" + ename + '\'' +
                '}';
    }
​
    public Integer getEmpNo() {
        return empNo;
    }
​
    public void setEmpNo(Integer empNo) {
        this.empNo = empNo;
    }
​
    public String getEname() {
        return ename;
    }
​
    public void setEname(String ename) {
        this.ename = ename;
    }
}
public class ApplicationContext {
​
    private static Map map ;//存储项目开发时的实例对象
​
    //Spring 容器类第一次被加载时，将项目中指定类的对象创建出来保存到容器
    static {
        map = new HashMap();
        map.put("dept",new Dept());
        map.put("emp",new Emp());
    }
​
​
    public static Object getBean(String key ){
        return map.get(key);
    }
}
public class Tes_IOC {
    public static void main(String[] args) {
        Dept dept = (Dept) ApplicationContext.getBean("dept");
        Emp emp = (Emp) ApplicationContext.getBean("emp");
        System.out.println("dept对象"+dept);
        System.out.println("emp对象"+emp);
    }
}

六、Spring框架中的DI服务：

  • 1、DI服务：依赖注入

  • 2、DI服务从IOC服务衍生的一个服务，用于帮助开发人员为对象的属性进行初始化操作

/**
 * @Target 注解描述当前自定义注解可以在哪些元素上进行声明
 * @Retention 注解描述当前自定义的注解有效范围
 *      1、开发阶段有效
 *      2、在编译阶段有效
 *      3、在运行时有效
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Value {
    //声明Value注解中的属性
    public String value() default "";
}
public class Dept {
​
    @Value(value = "10")
    private Integer deptNo;
    @Value(value = "Accounting")
    private String dname;
    private String loc;
​
    @Override
    public String toString() {
        return "Dept{" +
                "deptNo=" + deptNo +
                ", dname='" + dname + '\'' +
                ", loc='" + loc + '\'' +
                '}';
    }
​
    public Integer getDeptNo() {
        return deptNo;
    }
​
    public void setDeptNo(Integer deptNo) {
        this.deptNo = deptNo;
    }
​
    public String getDname() {
        return dname;
    }
​
    public void setDname(String dname) {
        this.dname = dname;
    }
​
    public String getLoc() {
        return loc;
    }
​
    public void setLoc(String loc) {
        this.loc = loc;
    }
}
//==================================================
public class Emp {
    @Value(value = "9527")
    private Integer empNo;
    @Value(value = "pm")
    private String ename;
​
    @Override
    public String toString() {
        return "Emp{" +
                "empNo=" + empNo +
                ", ename='" + ename + '\'' +
                '}';
    }
​
    public Integer getEmpNo() {
        return empNo;
    }
​
    public void setEmpNo(Integer empNo) {
        this.empNo = empNo;
    }
​
    public String getEname() {
        return ename;
    }
​
    public void setEname(String ename) {
        this.ename = ename;
    }
}
public class ApplicationContext {
​
    private static Map map ;//存储项目开发时的实例对象
​
    //Spring 容器类第一次被加载时，将项目中指定类的对象创建出来保存到容器
    static {
        map = new HashMap();
        try {
            map.put("dept",init(Dept.class));
            map.put("emp",init(Emp.class));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
​
    //侦测指定类中是否绑定了@Value注解，如若绑定，那么根据注解中的值对当前属性进行赋值
    private static Object init(Class classManager)throws Exception{
        Object obj = null;
        Field fieldArray[] = null;
        //1、通过class文件来申请创建当前类的实例对象
        obj = classManager.newInstance();
        //2、通过class文件得到当前类文件中所有的属性信息
        fieldArray = classManager.getDeclaredFields();
        //3、循环遍历，如果发现某个属性上绑定了@Value注解，则需要将注解中的值赋值给当前属性
        for (Field field:fieldArray){
            //3.1、询问当前属性是否关联了@Value注解
            if (field.isAnnotationPresent(Value.class)) {
                Value value = field.getAnnotation(Value.class);
                //从当前注解对象中得到value属性的值
                String field_Value = value.value();
                //将注解中的值赋值到当前对象的属性
                field.setAccessible(true);
                String typeName = field.getType().getSimpleName();
                if ("Inteder".equals(typeName)) {
                    field.set(obj, Integer.valueOf(field_Value));
                } else if ("Double".equals(typeName)) {
                    field.set(obj, Double.valueOf(field_Value));
                } else if ("String".equals(typeName)) {
                    field.set(obj, field_Value);
                }
            }
        }
        return obj;
    }
​
    public static Object getBean(String key ){
        return map.get(key);
    }
}
public class Test_DI {
    public static void main(String[] args) {
​
        Emp emp = (Emp) ApplicationContext.getBean("emp");
        System.out.println(emp.toString());
​
        Dept dept = (Dept) ApplicationContext.getBean("dept");
        System.out.println(dept.toString());
​
    }
}

七、通过xml文件向Spring容器索要IOC服务

  • 开发环境搭建

    • 1、向Maven索要Spring框架中spring-context.jar

    • 2、在resources下创建Spring框架的核心配置文件，通过该配置文件通知Spring容器当前项目中哪些类的对象需要由Spring容器来提供

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.5.RELEASE</version>
</dependency>
    <bean id="student" class="com.pm.entity.Student">
​
    </bean>
public class Student {
    public void sayHello(String name){
        System.out.println("hello : " + name);
    }
}
public class TestMain {
    /**
     * ApplicationContext 的两个接口实现类
     *
     * 1、FileSystemXmlApplicationContext：创建Spring 容器对象可以在当前计算机任意硬盘上
     *    读取指定的Spring核心配置文件
     *
     * 2、ClassPathXmlApplicationContext：创建的Spring容器对象只能在当前项目的编译路径下
     *    读取指定的核心配置文件
     */
    @Test
    public void test1(){
        //1、获取Spring容器对象,Spring容器对象在创建时自动读取指定的Spring核心配置。
        ApplicationContext spring = new ClassPathXmlApplicationContext("spring.xml");
        //2、向Spring容器对象索要Student类对象
        Student stu = (Student) spring.getBean("student");
        stu.sayHello("pm");
    }
​
    @Test
    public void test2(){
        //1、获取Spring容器对象,Spring容器对象在创建时自动读取指定的Spring核心配置。
        ApplicationContext spring = new ClassPathXmlApplicationContext("spring.xml");
        //2、连续向Spring容器索要两个Student类型对象
        Student stu1 = (Student) spring.getBean("student");
        Student stu2 = (Student) spring.getBean("student");
        System.out.println("stu1:" + stu1.toString());
        System.out.println("stu2:" + stu1.toString());
    }
​
    @Test
    public void test3(){
        //1、获取Spring容器对象,Spring容器对象在创建时自动读取指定的Spring核心配置。
        ApplicationContext spring = new ClassPathXmlApplicationContext("spring.xml");
        //2、获得Spring容器对象中所管理的所有实例对象的key
        String keys[] = spring.getBeanDefinitionNames();
        for (String key :
                keys) {
            System.out.println("key = "+key);
        }
    }
}
test1结果: hello : pm
test2结果：stu1:com.pm.entity.Student@6acdbdf5
          stu2:com.pm.entity.Student@6acdbdf5  
test3结果：key = student

八、通过xml文件向Spring容器索要DI服务

  • part1

public class School {
​
     private String shcoolName;
     private String address;
​
     public String getShcoolName() {
          return shcoolName;
     }
​
     public void setShcoolName(String shcoolName) {
          this.shcoolName = shcoolName;
     }
​
     public String getAddress() {
          return address;
     }
​
     public void setAddress(String address) {
          this.address = address;
     }
​
     @Override
     public String toString() {
          return "School{" +
                  "shcoolName='" + shcoolName + '\'' +
                  ", address='" + address + '\'' +
                  '}';
     }
}
         <bean id="school" class="com.pm.pack1.School">
               <property name="address" value="大湾区卷王9527房"/>
               <property name="shcoolName" value="卷王学院"/>
         </bean>
public class TestMain {
​
    @Test
    public void test1(){
        ApplicationContext spring = new ClassPathXmlApplicationContext("pack1/spring.xml");
        School school=(School) spring.getBean("school");
        System.out.println(school.toString());
    }
}

  • part2

public class School {
​
     private String shcoolName;
     private String address;
​
     public String getShcoolName() {
          return shcoolName;
     }
​
     public void setShcoolName(String shcoolName) {
          this.shcoolName = shcoolName;
     }
​
     public String getAddress() {
          return address;
     }
​
     public void setAddress(String address) {
          this.address = address;
     }
​
     @Override
     public String toString() {
          return "School{" +
                  "shcoolName='" + shcoolName + '\'' +
                  ", address='" + address + '\'' +
                  '}';
     }
}
//====================================================================
public class Student {
​
        private int sid;
        private String sname;
        private School school; //表示学员隶属的学校
        private List list;
​
    public List getList() {
        return list;
    }
​
    public void setList(List list) {
        this.list = list;
    }
​
    public int getSid() {
        return sid;
    }
​
    public void setSid(int sid) {
        this.sid = sid;
    }
​
    public String getSname() {
        return sname;
    }
​
    public void setSname(String sname) {
        this.sname = sname;
    }
​
    public School getSchool() {
        return school;
    }
​
    public void setSchool(School school) {
        this.school = school;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", sname='" + sname + '\'' +
                ", school=" + school +
                '}';
    }
}
         <bean id="myList" class="java.util.ArrayList"></bean>
         <!--
             property 通知Spring容器为当前对象中属性进行初始化操作
             property 指向的属性必须匹配set方法
         -->
         <bean id="school" class="com.pm.pack1.School">
               <property name="address" value="大湾区卷王9527房"/>
               <property name="shcoolName" value="卷王学院"/>
         </bean>
​
​
         <!--
              value 与  ref 区别
              如果需要赋值的属性是[基本数据类型],此时需要使用value属性指定其初始值
              如果需要赋值的属性是[高级引用数据类型],此时需要使用ref属性指定其初始值
              ref指向一个在Spring容器已经存在的对象的key
         -->
         <bean id="student" class="com.pm.pack2.Student">
             <property name="sid" value="10"/>
             <property name="sname" value="mike"/>
             <property name="school" ref="mySchool"/>
             <property name="list"   ref="myList"/>
         </bean>
public class TestMain {
​
    @Test
    public void test1(){
        ApplicationContext spring = new ClassPathXmlApplicationContext("pack2/spring.xml");
        Student student=(Student)spring.getBean("student");
        System.out.println(student.toString());
    }
}

  • part3

public class Student {
​
        private int sid;
        private String sname;
​
    public int getSid() {
        return sid;
    }
​
    public void setSid(int sid) {
        this.sid = sid;
    }
​
    public String getSname() {
        return sname;
    }
​
    public void setSname(String sname) {
        this.sname = sname;
    }
​
    public Student(int sid, String sname) {
        this.sid = sid;
        this.sname = sname;
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", sname='" + sname + '\'' +
                '}';
    }
}
        <!--
           默认的情况下，Spring容器对象调用指定类的【无参构造方法】来创建当前类的实例对象的
           如果当前类没有无参构造方法,此时可以通过constructor-arg标签要求Spring容器调用
           对应的有参构造方法来创建当前类的实例对象
         --> 
        <bean  id="student" class="com.pm.pack3.Student">
             <constructor-arg name="sid" value="20"/>
             <constructor-arg name="sname" value="mike"/>
         </bean>
public class TestMain {
​
    @Test
    public void test1(){
        ApplicationContext spring = new ClassPathXmlApplicationContext("pack3/spring.xml");
        Student stu = (Student)spring.getBean("student");
        System.out.println(stu.toString());
    }
}
test1结果：School{shcoolName='卷王学院', address='大湾区卷王9527房'}
test2结果：Student{sid=10, sname='mike', school=School{shcoolName='卷王学院', address='大湾区卷王9527房'}}    
test3结果：Student{sid=20, sname='mike'}

peng_miao_no1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring初探
foxbond的博客
04-25 298
Spring框架的主要功能是通过其核心容器来实现的。Spring框架提供了两种核心容器，分别是**BeanFactory**和**ApplicationContext**
初识Spring
aliceiwill的博客
01-02 1488
Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器开源框架 而JavaBean 是一种JAVA语言写成的可重用组件。为写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。JavaBean 通过提供符合一致性设计模式的公共方法将内部域暴露成员属性，set和get方法获取。众所周知，属性名称符合这种模式，其他Java 类可以通过自省机制(反射机制)发现和操作这些J...
代码评审——对field.getType().getSimpleName()的判断问题
月空的博客
11-29 708
当项目中，需要根据类型来进行一些操作时，如果仅是简单用String.equals()来进行判断，很容易出现问题。
Java学习第二十二天 反射
图南的博客
07-21 199
反射概述 反射(reflection)的概念是由Smith于1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。通俗的讲就是反射可以在运行时根据执行的类名获得类的信息 Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反...
01-SpringSecurity初见
空夜's Blog
06-04 884
今天开始来讲述一下SpringBoot2.0 + SpringSecurity的使用。注意哦，我这里用的SpringBoot2.x自带的SpringSecurity，所以在某些细节上跟其他教程、博客有所不同。 maven依赖： <dependency> <groupId>org.springframework.boot</groupId> <art...
Spring源码之ApplicationContext
Sdj356512265的博客
03-05 351
本文是针对Srping的ClassPathXMLApplicationContext来进行源码解析,在本篇博客中将不会讲述spring Xml解析注册代码，因为ApplicationContext是BeanFactory的扩展版本，ApplicationContext的GetBean和xml解析注册BeanDefinition都是用一套代码，如果您是第一次看请先看一下XMLBeanFactory解析和BeanFactory.GetBean源码解析： XMLBeanFactory源码解析地址：Srping
Spring框架开天辟地：如果让我设计Spring？
weixin_39997751的博客
12-17 556
前前后后写了几篇Spring的源码分析，看着寥寥无几的阅读量，我意识到了自己写的不够好，虽然我的流程图、源码注释花了不少时间，可阅读量摆在那，就是不够好。 思来想去，我决定再加一篇更加通俗、直观的文章：假如让我们来设计Spring框架，我们该怎么设计，我们会想到什么问题，又该如何解决这些问题。 好的开始吧。 让我们回到2008年7月11日的早晨。 最近我们在项目开发中，遇到了如下的问题，感觉很繁琐，我想搞一个框架出来，方便日后的项目开发： 项目中有很多服务类对象，对象间引用极其麻烦，都用单例模式的话，那
Spring实现数据库读写分离代码
04-12
本示例中，我们关注的是如何利用Spring框架来实现这一功能，结合Spring MVC、Spring以及MyBatis，以及MySQL数据库。以下是关于这个主题的详细讲解： 1. **Spring MVC**：Spring MVC是Spring框架的一个模块，主要...
spring boot招聘系统设计
05-01
**Spring Boot招聘系统设计** Spring Boot是Java领域中一个非常流行的框架，用于简化Spring应用程序的初始设置和开发过程。在本项目中，我们将探讨如何利用Spring Boot构建一个招聘系统，该系统可以支持企业发布...
SpringBoot项目初始化搭建
weixin_63405049的博客
08-30 1959
本章主要讲解了SpringBoot项目初始化搭建，编程事务的使用，分页依赖的使用，以及跨域问题如何解决，解决了轻量级项目构建初期遇到的一些问题，提供于前后端交互时产生的问题进行分析与解决
Spring理论知识（Ⅳ）——Spring Instrumentation模块
敢问路在何方，路在脚下
09-02 746
总的来说，Spring Instrumentation提供了类植入（Instrumentation）支持和类加载器的实现，可以在特定的应用服务器中使用。本质上是一种JVM级别（操作系统级别）的AOP，用到了代理java.lang.instrument（容器类）做动态Instrumentation是Java SE 5的新特性使用 Instrumentation，开发者可以构建一个独立于应用程序的代理程序（Agent），用来监测和协助运行在 JVM 上的程序，甚至能够替换和修改某些类的定义。
自己开发完整项目一、登录功能-03(使用springSecurity安全框架,查询用户角色权限)
qq_40072583的博客
08-31 860
在前面两章节，实现了通过springsecurity来进行用的登录认证，当用户输入用户名和密码之后，通过额数据库中的信息比对，比对成功那么放行。但是还存在一个问题：因为系统的所有页面包括按钮都是有各自的权限，那么要想实现不同的用户登录成功看到的页面不同并且有不同的操作范围，那么就需要对用户的权限进行验证。实现的思路:在用户登录的时候，将用户的权限查询出来。
基于Spring和MybatisPlus下的Oracle转mysql语句语法适配修改
xingyuemengjin的博客
09-04 453
本文讲述了在Spring+MybatisPlus环境中，oracle数据库转为mysql后查询语法和代码的主要修改。
【安全漏洞】SpringBoot + SpringSecurity CORS跨域资源共享配置
最新发布
weixin_42925623的博客
09-05 817
今天我们就来了解一下这个CROS漏洞，并记录一下在整合了springSecurity这一套安全框架下的springboot系统中如何在后端过滤器中通过正确注册WebMvcConfigurer bean来配置CORS的全局设置，实现对非白名单访问源的拦截。
Spring MVC 八股文
szchen2的博客
09-02 1381
Spring MVC 是 Spring 提供的一个基于 MVC 设计模式的轻量级 Web 开发框架，本质上相当于 Servlet。它将model、view、controller分离，对web层进行解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。
spring security 会话管理
冬阳
08-31 1264
当浏览器调用登录接口登录成功后，服务端会和浏览器之间建立一个会话(Session)浏览器在每次发送请求时都会携带一个 Sessionld，服务端则根据这个 Sessionld 来判断用户身份当浏览器关闭后，服务端的 Session 并不会自动销毁，需要开发者手动在服务端调用Session销毁方法，或者等 Session 过期时间到了自动销毁。
Spring Security 用户认证和授权管理
weixin_44876263的博客
09-02 1150
文章目录一、介绍1、简介2、核心概念3、主要功能4、处理流程二、Spring Security实现权限1、添加依赖2、执行顺序和代码执行流程（1）用户登录（2）访问受保护资源总结1、用户登录2、访问受保护资源完整源码 一、介绍 1、简介 Spring Security 是一个强大的安全框架，旨在保护基于 Spring 的应用程序。它提供了一整套全面的安全功能，包括认证、授权、以及防护常见安全攻击的机制。 2、核心概念 认证（Authentication） 认证是验证用户身份的过程。在 Spring S
Spring TransactionTemplate 深入解析与高级用法
DS_Watson的博客
09-02 768
TransactionTemplate` 是 Spring 框架中一个强大的工具，它允许开发者以编程方式控制事务。通过本文的详细解析和示例代码，我们可以看到如何使用 `TransactionTemplate` 来执行事务性操作，并处理高级事务场景。在实际开发中，合理使用事务管理对于确保数据一致性和系统稳定性至关重要。
Spring实践指南
"Spring in Practice" 是一本关于Spring框架的实践指南，类似于"Spring in Action"，适合有一定英文基础的读者阅读。本书由Willie Wheeler和Joshua White合作撰写，覆盖了Spring 3版本的内容。 在Spring框架的实践...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值