一篇文章带你了解Java Spring基础与IOC

目录
  • About Spring
  • About IOC
  • Hello Spring
    • Hello.java
    • Beans.xml
    • Test.java
  • IOC创建对象的几种方式
  • Spring import settings
  • Dependency Injection
    • 1.构造器注入
    • 2.set注入
    • 3.拓展注入
  • P-namespcae&C-namespace
  • Bean scopes
  • singleton
  • prototype
  • Bean的自动装配
    • byName autowire
    • byType autowire
  • 小结

About Spring

开源免费框架,轻量级,非入侵式框架。Spring就是一个轻量级的控制反转(IOC)和面向切片编程(AOP)的框架

Maven repo:Spring Web MVC + spring-jdbc(整合Mybatis)

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.9</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.9</version>
</dependency>

Spring两大特点

  • 控制反转(IOC)
  • 面向切片编程(AOP)支持事务处理

About IOC

控制反转:IOC是一种设计思想,通过描述(XML或注解)并通过第三方生产或获取对象的方式。之前对象的创建与对象的依赖关系完全在java硬编码程序中,控制权在程序;实现IOC后,控制权在第三方,实现降藕。

在Spring中实现控制反转的是 IoC容器 ,实现方法是 依赖注入DI(Dependency Injection,DI)

引用狂神的一个例子简单理解下

private UserDao userDao = null;

public UserServiceImpl(){
    userDao = new UserDaoImpl();
}

在之前我们使用JavaWeb写service=>dao的时候,是通过如上的方式去实现的,项目构建大概如下

那么如果此时我的UserDao接口又了一个新的实现类暂且为 UserDaoImpls ,这个实现类中有新的功能实现,那么就需要到UserServiceImpl中再去构造方法加一段如下的代码:

userDao = new UserDaoImpls();

那么这时如果该项目还没发布那到无所谓,如果是已经上线的项目是不可能这样重新去修改代码的,或者如果有n个new,就要修改n处。

解决这个问题就是通过一个set方法。如下:

public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

在构造方法中实例化对象的这个操作,改为利用set封装并将需要new的实现类的名称变为set方法的参数,实现用户可控的去new一个新的实现类从而添加新的功能展示到页面。

而这个思想就是控制反转(IOC)的原型,将new实现类对象的主动权交给了用户而不是程序,从本质上解决了上面的问题,也实现了降藕。

Hello Spring

Hello.java

package com.zh1z3ven.pojo;

public class Hello {
    private String str;

    public Hello() {
    }

    public Hello(String str) {
        this.str = str;
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

Beans.xml

一个bean标签代表一个对象, id代表在Spring中这个类要实例化生成的对象的名字, class指定这个实体类

设置对象的属性值

引用Spring容器中创建的对象

<?xml version="1.0" encoding="UTF-8"?>
<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--使用Spring创建对象,Spring都称之为bean-->
<!--    一个bean标签代表一个对象, id代表要实例化的对象的名字, class指定这个实体类-->
    <bean id="hello" class="com.zh1z3ven.pojo.Hello">
<!--        设置实体类的属性值-->
        <property name="str" value="Spring"/>
    </bean>
</beans>

Test.java

在Spring中也存在一个上下文,通过 ApplicationContext context = new ClassPathXmlApplicationContext(“beans.xml”); 传入xml配置文件名字来获取该xml文件的上下文对象。利用 ApplicationContext#getBean() 传入在xml中配置的该类的id获取该实体类对象。

public class MyTest {
    public static void main(String[] args) {

        //获取Spring上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //从Spring中取出对象
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);

    }
}

IOC创建对象的几种方式

PS:在配置文件加载的时候,通过bean标签注册的对象就已经在Spring IoC容器中初始化了。

总体来说就两种方式:

无参构造

默认使用

有参构造

  • 下标赋值
<!--通过下标赋值-->
<bean id="hello2" class="com.zh1z3ven.pojo.Hello">
    <constructor-arg index="0" value="Spring2"/>
</bean>
  • 类型复制
<!--通过类型赋值-->
<bean id="hello3" class="com.zh1z3ven.pojo.Hello">
    <constructor-arg type="java.lang.String" value="Spring3"/>
</bean>
  • 属性名赋值
<!--属性名赋值-->
<bean id="hello4" class="com.zh1z3ven.pojo.Hello">
    <constructor-arg name="str" value="Spring4"/>
</bean>

Spring import settings

import标签可导入其他beans.xml配置文件,而applicationContext.xml到时可作为总bean的配置文件,而不需要导入多个xml

Dependency Injection

依赖注入(Dependency Injection,DI)
PS:一定需要pojo中实现set才可以利用bean标签注入

1.构造器注入

也就是上面提到的创建对象的方式,分为无参构造和有参构造

无参构造

默认使用

有参构造

  • 下标赋值
<!--通过下标赋值-->
<bean id="hello2" class="com.zh1z3ven.pojo.Hello">
    <constructor-arg index="0" value="Spring2"/>
</bean>
  • 类型复制
<!--通过类型赋值-->
<bean id="hello3" class="com.zh1z3ven.pojo.Hello">
    <constructor-arg type="java.lang.String" value="Spring3"/>
</bean>
  • 属性名赋值
<!--属性名赋值-->
<bean id="hello4" class="com.zh1z3ven.pojo.Hello">
    <constructor-arg name="str" value="Spring4"/>
</bean>

2.set注入

依赖:bean对象的注入依赖于Spring容器

注入:bean对象的属性,由容器来注入

3.拓展注入

Student.java

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private String apache;
    private Properties info;

    public String getApache() {
        return apache;
    }

    public void setApache(String apache) {
        this.apache = apache;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbys() {
        return hobbys;
    }

    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbys=" + hobbys +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

beans.xml

<bean id="address" class="com.zh1z3ven.pojo.Address">
    <property name="address" value="beijing"/>
</bean>
<bean id="student1" class="com.zh1z3ven.pojo.Student">
<!--        普通属性值注入-->
    <property name="name" value="zh1z3ven"/>

<!--        ref 引用对象注入-->
    <property name="address" ref="address"/>

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

<!--        List注入-->
    <property name="hobbys">
        <list>
            <value>听音乐</value>
            <value>看电影</value>
            <value>敲代码</value>
            <value>写文章</value>
        </list>
    </property>

<!--        Map注入-->
    <property name="card">
        <map>
            <entry key="银行卡" value="1"></entry>
            <entry key="身份证" value="2"></entry>
            <entry key="学生证" value="3"></entry>
            <entry key="电话卡" value="4"></entry>
            <entry key="校园卡" value="5"></entry>
        </map>
    </property>

<!--        Set注入-->
    <property name="games">
        <set>
            <value>LOL</value>
            <value>CF</value>
            <value>qq</value>
        </set>
    </property>

<!--        null注入-->
    <property name="wife">
        <null></null>
    </property>

<!--        空值注入-->
    <property name="apache" value=""/>

<!--        properties-->
    <property name="info">
        <props>
            <prop key="id">10</prop>
            <prop key="city">北京</prop>
        </props>
    </property>
</bean>

P-namespcae&C-namespace

1.p命名空间注入,可以直接注入属性值,类似于bean标签中property-name-value

Beans.xml头部需导入

xmlns:p="http://www.springframework.org/schema/p"
<bean id="user1" class="com.zh1z3ven.pojo.User" p:name="zh1z3ven1" p:age="18"/>

2.c命名空间注入,通过构造器注入,类似于construct-args(需要实现有参构造)

xmlns:c="http://www.springframework.org/schema/c"
<bean id="user2" class="com.zh1z3ven.pojo.User" c:name="zh1z3ven2" p:age="19"/>
@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User user1 = context.getBean("user1", User.class);
    System.out.println(user1.getName());
    System.out.println(user1.getAge());

    User user2 = context.getBean("user2", User.class);
    System.out.println(user2.getName());
    System.out.println(user2.getAge());
}

Bean scopes

bean的作用域

singleton

默认bean为scope = singleton单例模式运行的

显示定义:<bean id="user1" class="com.zh1z3ven.pojo.User" p:name="zh1z3ven1" p:age="18" scope="singleton"/>

单例模式,共享一个对象,比如如下例子,getBean指向的是同一个bean,那么在Spring IoC容器中仅仅会生成一个"user2"对象保存在内存中,当调用ApplicationContext.getBean(“user2”)时返回该对象

<bean id="user2" class="com.zh1z3ven.pojo.User" c:name="zh1z3ven2" c:age="19"/>
@Test
public void test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    User user1 = context.getBean("user2", User.class);
    User user2 = context.getBean("user2", User.class);
    System.out.println(user1==user2);
}

prototype

原型模式prototype与singleton不同,每次上下文去getBean()时都会在Spring IoC容器内创建一次该对象

还是拿上面的测试代码,可以发现已经不是同一个对象了,有点类似于多态

public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user1 = context.getBean("user2", User.class);
        User user2 = context.getBean("user2", User.class);
        System.out.println(user1==user2);
    }

而其余的生命周期在Web中才会遇到。

Bean的自动装配

  • 在xml显示配置bean
  • 在java代码中配置bean
  • 隐式自动装配bean【autowire】

byName autowire

会在容器上下文中自动查找,和自己对象set方法后面的值对应的beanid。也就是这里会去上下文中寻找有无"cat"这个beanid,有则自动装配,如果并没有匹配上,比如此时beanid被修改为了"cat123" 就会跑出异常。

byType autowire

会在容器上下文中寻找该类型与属性值所对应的类型相同的bean,基于bean中的class(需要在上下文中所有类型各自只出现一次)

<bean id="people" class="com.zh1z3ven.pojo.People" autowire="byType">
    <property name="name" value="zh1z3ven"/>
</bean>

小结

  • byname需要保证所有bean的id唯一,且这个bean的id的值要和需要自动装配依赖注入的set方法的值一致。
  • bytype需要保证所有bean的class唯一,且这个bean的class的值需要和set方法的值的类型一致。

注解实现自动装配
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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

@Autowired

默认使用byname方式去自动装配,它可以对类成员变量、方法及构造函数进行标注,完成自动装配的工作。

在使用@Autowired时,首先在容器中查询对应类型的bean(bytype)

如果查询结果刚好为一个,就将该bean装配给@Autowired指定的数据

如果查询的结果不止一个,那么@Autowired会根据名称来查找。(byname)

如果查询的结果为空,那么会抛出异常。解决方法时,使用@Autowried(required=false)

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;

@Qualifier

如果存在多个类型且该类型有多个不同名字的对象,那么只用@Autowired会找不到该对象,可以配合@Qualifier(value="")来指定一个装配的值。

@Autowired
@Qualifier(value="dog222")

@Resource

java自带的一个注解,和@Autowired,@Qualifier组合用法和效果基本是一样

javax.annotation.Resource
@Resource //不指定名称自动装配
@Resource(name="") //指定名称自动装配

使用注解开发

bean在xml里注册,属性值通过注解注入

@component

泛指各种组件,把普通pojo实例化到spring容器中,相当于配置文件中的bean,将该类在配置文件下注册到Spring容器中装配bean。类似的还有:

1、@controller 控制器(注入服务) 用于标注控制层,相当于struts中的action层
2、@service 服务(注入dao) 用于标注服务层,主要用来进行业务的逻辑处理
3、@repository(实现dao访问) 用于标注数据访问层,也可以说用于标注数据访问组件,即DAO组件

##@Scope
生命周期,用法:在目标类上面声明

@Scope("singleton")

@Configuration

用于声明这是一个配置类

@Bean

相当于在配置文件中注册bean

方法名为之前的id属性

方法返回值为之前的class属性

@Import

导入其他配置类,等价于

<import resource="beans.xml"/>

使用方法

@Import(Config.class)

示例代码

pojo

//相当于在bean中注册,相当于在Spring IoC容器new一个对象
@Component
public class User {
    @Value("CoLoo")
    public String name;

    public String getName() {
        return name;
    }

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

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

config

@Configuration
@ComponentScan("com.zh1z3ven.pojo")
public class AppConfig {
    @Bean
    public User getUser(){
        return new User();
    }
}

test

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        User user = context.getBean("user", User.class);
        System.out.println(user.getName());
    }
}

以上就是一篇文章带你了解Java Spring基础与IOC的详细内容,更多关于Java Spring与IOC的资料请关注我们其它相关文章!

(0)

相关推荐

  • 浅析Java的Spring框架中IOC容器容器的应用

    Spring容器是Spring框架的核心.容器将创建对象,它们连接在一起,配置它们,并从创建到销毁管理他们的整个生命周期.在Spring容器使用依赖注入(DI)来管理组成应用程序的组件.这些对象被称为Spring Beans. 容器获得其上的哪些对象进行实例化,配置和组装通过阅读提供的配置元数据的说明.配置元数据可以通过XML,Java注释或Java代码来表示.下面的图是Spring如何工作的高层次图. Spring IoC容器是利用Java的POJO类和配置元数据的产生完全配置和可执行的系统或

  • 用java的spring实现一个简单的IOC容器示例代码

    要想深入的理解IOC的技术原理,没有什么能比的上我们自己实现它.这次我们一起实现一个简单IOC容器.让大家更容易理解Spring IOC的基本原理. 这里会涉及到一些java反射的知识,如果有不了解的,可以自己去找些资料看看. 注意 在上一篇文章,我说,启动IOC容器时,Spring会将xml文件里面配置的bean扫描并实例化,其实这种说法不太准确,所以我在这里更正一下,xml文件里面配置的非单利模式的bean,会在第一次调用的时候被初始化,而不是启动容器的时候初始化.但是我们这次要做的例子是容

  • Java基础之Spring5的核心之一IOC容器

    一.什么是IOC 1)控制反转,把创建对象和对象的调用过程交给Spring 管理. 2)使用IOC的目的,为了降低耦合度. 二.IOC的底层原理 XML解析.工厂模式.反射 三.IOC思想 基于IOC容器完成,IOC容器底层就是对象工厂. 四.Spring 提供IOC容器实现两种方式:(两个接口) (1)BeanFactory:IOC容器基本实现,是Spring内部的使用接口,不提供开发人员使用 特点:加载配置文件的时候不会创建对象,在获取(使用)对象才去创建. (2)ApplicationCo

  • 深入理解Java的Spring框架中的IOC容器

    Spring IOC的原型 spring框架的基础核心和起点毫无疑问就是IOC,IOC作为spring容器提供的核心技术,成功完成了依赖的反转:从主类的对依赖的主动管理反转为了spring容器对依赖的全局控制. 这样做的好处是什么呢? 当然就是所谓的"解耦"了,可以使得程序的各模块之间的关系更为独立,只需要spring控制这些模块之间的依赖关系并在容器启动和初始化的过程中将依据这些依赖关系创建.管理和维护这些模块就好,如果需要改变模块间的依赖关系的话,甚至都不需要改变程序代码,只需要将

  • Spring学习笔记1之IOC详解尽量使用注解以及java代码

    在实战中学习Spring,本系列的最终目的是完成一个实现用户注册登录功能的项目. 预想的基本流程如下: 1.用户网站注册,填写用户名.密码.email.手机号信息,后台存入数据库后返回ok.(学习IOC,mybatis,SpringMVC的基础知识,表单数据验证,文件上传等) 2.服务器异步发送邮件给注册用户.(学习消息队列) 3.用户登录.(学习缓存.Spring Security) 4.其他. 边学习边总结,不定时更新.项目环境为Intellij + Spring4. 一.准备工作. 1.m

  • 深入理解java的spring-ioc的使用

    spring-ioc的使用 IOC容器在很多框架里都在使用,而在spring里它被应用的最大广泛,在框架层面上,很多功能都使用了ioc技术,下面我们看一下ioc的使用方法. 把服务注册到ioc容器 使用属性注入反射对应类型的实例 多态情况下,使用名称反射类型的实例 把服务注册到ioc容器 @Bean注册组件 使用@Bean注解进行类型的注册,默认你的ioc容器里类型为bean的返回值,名称为bean所有的方法名,与你的包名称没有直接关系,如果你的接口有多种实现,在注册时可以使用@Bean("li

  • 使用Java注解模拟spring ioc容器过程解析

    使用注解,简单模拟spring ioc容器.通过注解给对象属性注入值. 项目结构 annotation 包,用于存放自定义注解 Component 注解表示该类为组件类,并需要声明名字 package priv.haidnor.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy;

  • 使用Java反射模拟实现Spring的IoC容器的操作

    目录 实现的功能: 项目结构 下面是程序的项目结构图: 自定义注解 容器实现 测试 实体类User的定义: 实现的功能: 默认情况下将扫描整个项目的文件 可以使用@ComponentScan注解配置扫描路径 只将被@Component注解修饰的类装载到容器中 可以使用@AutoWired注解实现自动装配 读取配置文件中的声明的类并注册到容器中 项目结构 下面是程序的项目结构图: 自定义注解 下面是自定义的三个注解: @AutoWired,@Component,@ComponentScan. @T

  • 一篇文章带你了解Java Spring基础与IOC

    目录 About Spring About IOC Hello Spring Hello.java Beans.xml Test.java IOC创建对象的几种方式 Spring import settings Dependency Injection 1.构造器注入 2.set注入 3.拓展注入 P-namespcae&C-namespace Bean scopes singleton prototype Bean的自动装配 byName autowire byType autowire 小结

  • 一篇文章带你理解Java Spring三级缓存和循环依赖

    目录 一.什么是循环依赖?什么是三级缓存 二.三级缓存如何解决循环依赖? 三.使用二级缓存能不能解决循环依赖? 总结 一.什么是循环依赖?什么是三级缓存 [什么是循环依赖]什么是循环依赖很好理解,当我们代码中出现,形如BeanA类中依赖注入BeanB类,BeanB类依赖注入A类时,在IOC过程中creaBean实例化A之后,发现并不能直接initbeanA对象,需要注入B对象,发现对象池里还没有B对象.通过构建函数创建B对象的实例化.又因B对象需要注入A对象,发现对象池里还没有A对象,就会套娃.

  • 一篇文章带你了解Java中ThreadPool线程池

    目录 ThreadPool 线程池的优势 线程池的特点 1 线程池的方法 (1) newFixedThreadPool (2) newSingleThreadExecutor (3) newScheduledThreadPool (4) newCachedThreadPool 2 线程池底层原理 3 线程池策略及分析 拒绝策略 如何设置maximumPoolSize大小 ThreadPool 线程池的优势 线程池做的工作主要是控制运行的线程数量,处理过程中将任务放入队列,然后在线程创建后启动这些

  • 一篇文章带你了解初始Spring

    目录 为什么要使用Spring Spring概述 Spring容器使用流程 1.启动容器 2.完成bean的初始化 3.注册bean到容器中 4.装配bean的属性 bean的注册 bean属性注入 总结 为什么要使用Spring Why Spring? Spring makes programming Java quicker, easier, and safer for everybody. Spring's focus on speed, simplicity, and productiv

  • 一篇文章带你详解Spring的概述

    目录 1.什么是 Spring ? 2.Spring 起源 3.Spring 特点 ①.方便解耦,简化开发 ②.AOP编程的支持 ③.声明式事务的支持 ④.方便程序的测试 ⑤.方便集成各种优秀框架 ⑥.降低Java EE API的使用难度 ⑦.Java 源码是经典学习范例 4.Spring 框架结构 5.Spring 框架特征 6.Spring 优点 总结: 1.什么是 Spring ? Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Jo

  • 一篇文章带你了解Java基础-多态

    目录 Java基础知识(多态) 多态 多态的定义和存在的必要条件 多态的案例 多态的弊端 引用类型转换 总结 Java基础知识(多态) 多态 多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量到底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定. 因为在程序运行时才确定具体的类,这样,不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致该引用

  • 一篇文章带你了解Java基础-接口

    目录 Java基础知识(接口) 接口 接口的定义 接口和抽象的区别 接口的格式 接口中的主要成分 接口的案例 接口与接口的关系 JDK 8之后的接口新增方法 总结 Java基础知识(接口) 接口 Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为(功能). 接口的定义 接口: 在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明.一个类通过继承接口

  • 一篇文章带你了解Java基础-抽象

    目录 Java基础知识(抽象) 抽象 抽象定义 abstract的使用 定义抽象类 抽象类的一些注意点 总结 Java基础知识(抽象) 抽象 抽象是从众多的事物中抽取出共同的.本质性的特征,而舍弃其非本质的特征的过程.具体地说,抽象就是人们在实践的基础上,对于丰富的感性材料通过去粗取精.去伪存真.由此及彼.由表及里的加工制作,形成概念.判断.推理等思维形式,以反映事物的本质和规律的方法. 抽象定义 在继承过程中,我们知道父类的方法可以子类进行重写,而每个子类各自的实现都不尽相同.就好比动物都有吃

  • 一篇文章带你详解Spring的AOP

    目录 1.AOP 什么? 2.需求 3.解决办法1:使用静态代理 第一步:创建 UserService 接口 第二步:创建 UserService的实现类 第三步:创建事务类 MyTransaction 第四步:创建代理类 ProxyUser.java 4.解决办法2:使用JDK动态代理 5.AOP 关键术语 6.AOP 的通知类型 7.使用 Spring AOP 解决上面的需求 上面的配置我们在注释中写的很清楚了.这里我们重点讲解一下: ①.切入点表达式,一个完整的方法表示如下: ②.spri

  • 一篇文章带你复习java知识点

    JDK JRE JVM JDK: Java标准开发包,它提供了编译.运⾏Java程序所需的各种⼯具和资源,包括Java编译器.Java运⾏时环境,以及常⽤的Java类库等. JRE: Java运⾏环境,⽤于解释执⾏Java的字节码⽂件. JVM Java虚拟机,是JRE的⼀部分.负责解释执⾏字节码⽂件,是可运⾏java字节码⽂件的虚拟计算机 区别联系:(问答题会考可能) JDK包含JRE,JDK 和 JRE 中都包含 JVM.JDK出了包含jre还包含⼀些常⽤开发⼯具和基础类库 JDK ⽤于开发

随机推荐