JunChow520
JunChow520

SpringIoC

Spring

  • IoC：容器
  • AOP：事务处理

http://spring.io

Spring发展至今已经形成了一种开发的生态圈，Spring提供了若干个项目，每个项目用户完成特定的功能。

Spring发展史

Spring Framework 系统架构

Spring Framework是Spring生态圈中最基础的项目，也是其他项目的根基。

架构历史
系统架构
系统架构 说明
Core Contianer 核心容器
AOP 面向切面编程
Aspects AOP思想实现
Data Access 数据访问
Data Integration 数据集成
Web Web开发
Test 单元测试与集成测试

核心容器

传统代码书写业务层实现与数据层实现耦合度偏高，因为使用对象时主动靠new产生。如何解决这个问题？只要转换为由外部提供对象，就可以达到解耦的目的。

IoC(Inversion of Control)控制反转，其核心思想是将对象创建的控制权由程序内部转移到外部。使用对象时由原来主动new产生对象的方式，转换为由外部提供对象，此过程中对象创建的控制权就由程序内部转移到外部。

Spring技术对IoC思想进行了实现，Spring提供了一个容器（IoC容器），用来充当IoC思想中的“外部”。

IoC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器称为Bean。

DI(Dependency Injection)依赖注入，在容器中建立Bean与Bean之间的依赖关系的整个过程称为注入。

依赖注入

为了充分解耦，使用IoC容器管理Bean，在IoC容器内将具有依赖关系的Bean进行关系绑定（DI）。最终达到效果是使用对象时不仅可以直接从IoC容器中获取，而且获取到的Bean已经绑定了所有依赖关系。

案例：XML版的IoC快速入门

  1. 导入SpringFramework的坐标spring-context 
$ vim pom.xml



    4.0.0

    com.jc
    sl
    1.0-SNAPSHOT

    
        
            org.springframework
            spring-context
            5.2.10.RELEASE
  1. 创建Spring配置文件，配置指定类作为Spring管理的Bean。
$ vim resources/applicationContext.xml

Bean配置格式：
属性 说明
id 表示为Bean起名字，同一个上下文中禁止同名。
class 表示为Bean定义类型

注意：需要提前创建IoC容器要管理的对象

  1. 初始化IoC容器，通过容器获取指定Bean。
$ vim src/App.java

package com.jc;

import com.jc.dao.BaseDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BaseDao bd = (BaseDao)ctx.getBean("baseDao");
        System.out.println(bd);
    }
}
  • ClassPathXmlApplicationContext()方法用于加载配置文件以得到上下文对象（容器对象）
  • getBean()方法用于获取资源

案例：DI入门案例

配置Service与DAO之间的关系

$ vim resource/applicationContext.xml

property属性标签用于配置当前Bean的属性
属性 说明
name 表示配置具体哪个属性，baseDao对应的是com.jc.dao.impl.BaseDaoImpl类中的名为private BaseDaoImpl baseDao;的属性。
ref 表示参照那个Bean，baseDao对应的是

删除以往使用new的方式创建对象，提供依赖对象userDao对应的setter方法，配置Service与DAO之间的关系。

$ vim jc/com/service/impl/BaseServiceImpl.java

package com.jc.service.impl;

import com.jc.dao.impl.BaseDaoImpl;
import com.jc.service.BaseService;

public class BaseServiceImpl implements BaseService {
    private BaseDaoImpl baseDao;

    public void setBaseDao(BaseDaoImpl baseDao) {
        this.baseDao = baseDao;
    }
}

Bean的配置

  • Bean基础配置
  • Bean别名配置
  • Bean的作用范围
类别 说明
标签
所属
功能 定义Spring核心容器管理的对象
格式
属性 说明
id Bean的id，使用容器时可通过Bean的id获取对应的Bean，在一个容器中id值唯一。
name Bean的别名，支持多个，支持逗号/分号/空格分割。功能和id相同。
class Bean的类型，配置Bean的全路径类名。

获取Bean时无论是采用id还是name属性，无法获取时都会抛出异常NoSuchBeanDefinitionException。

默认IoC创建的Bean是单例的singleton

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
BaseDao bd1 = (BaseDao)ctx.getBean("baseDao");
BaseDao bd2 = (BaseDao)ctx.getBean("baseDao");
System.out.println(bd1);//com.jc.dao.impl.BaseDaoImpl@2f686d1f
System.out.println(bd2);//com.jc.dao.impl.BaseDaoImpl@2f686d1f
System.out.println(bd1==bd2);//true

若需要IoC创建的Bean不是单例的则需要在配置Bean时添加并修改scope属性，默认scope不写其值是singleton单例的。
类别 说明
属性 scope
所属
功能 定义Bean的作用范围

scope的取值范围

scope 说明
singleton 默认值，单例模式
prototype 非单例，原生值。 
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
BaseDao bd1 = (BaseDao)ctx.getBean("baseDao");
BaseDao bd2 = (BaseDao)ctx.getBean("baseDao");
System.out.println(bd1);//com.jc.dao.impl.BaseDaoImpl@2f686d1f
System.out.println(bd2);//com.jc.dao.impl.BaseDaoImpl@3fee9989
System.out.println(bd1==bd2);//false

为什么Bean默认是单例的呢？

Spring的IoC管理的Bean是会重复使用的，因此默认采用的单例。因此适合交给容器管理的Bean主要包括以下几种：表现层对象（Servlet）、业务层对象（Service）、数据层对象（DAO）、工具对象（Util）。不适合交给容器管理的Bean主要是有状态信息记录的对象，比如：封装实体的域对象。

Bean的创建（实例化）

  • 使用构造方法来创建
  • 使用静态工厂来创建
  • 使用实例工厂来创建
  • 使用FactoryBean来创建

Bean本质上是对象，创建Bean也就是创建对象，创建对象一般采用的是【new+构造方法】的方式来完成的。

  • Spring创建对象采用的是反射机制

例如：私有构造方法能被调用是由于采用了反射机制来创建对象

public class BaseDaoImpl implements BaseDao {
    private BaseDaoImpl(){
        System.out.println("BASE DAO CONSTRUTOR IS RUNNING...");
    }
}
  • Spring创建对象时调用的是无参的构造方法
public class BaseDaoImpl implements BaseDao {
    public BaseDaoImpl(int i){
        System.out.println("BASE DAO CONSTRUTOR IS RUNNING...");
    }
}

出现异常

BeanCreationException: Error creating bean with name 'baseDao' defined in class path resource [applicationContext.xml]...
BeanInstantiationException: Failed to instantiate [com.jc.dao.impl.BaseDaoImpl]: No default constructor found; 
Caused by: java.lang.NoSuchMethodException: com.jc.dao.impl.BaseDaoImpl.()

实例化Bean的方式

  1. 提供可访问的构造方法

使用构造方法创建的对象如何交给容器来管理呢？
  1. 使用静态工厂创建对象如何交给Spring的IoC来管理呢？

此种方式主要是为了兼容早期遗留下的系统的使用方式

创建静态工厂类

$ vim factory/BaseFactory.java

package com.jc.factory;

import com.jc.dao.BaseDao;
import com.jc.dao.impl.BaseDaoImpl;

public class BaseFactory {
    public static BaseDao createBaseDao(){
        System.out.println("BASE FACTORY SETUP...");
        return new BaseDaoImpl();
    }
}
  1. 使用实例工厂实例化Bean

创建实例工厂

$ vim /factory/BaseFactory.java

public class BaseFactory {
    public BaseDao createBaseDao(){
        System.out.println("BASE FACTORY SETUP...");
        return new BaseDaoImpl();
    }
}

配置实例工厂

$ vim resources/applicationContext.xml

Spring为简化实例工厂编写的复杂性，创建了一个名为FactoryBean的泛型接口。

  1. 使用FactoryBean方式实例化Bean

创建实例工厂同时实现FactoryBean接口

$ vim factory/BeaseFactory.java

public class BaseFactory implements FactoryBean {
    //代替原始实例工厂中创建对象的方法，统一采用相同的名称都为getObject。
    @Override
    public BaseDao getObject() throws Exception {
        return new BaseDaoImpl();
    }
    @Override
    public Class getObjectType() {
        return BaseDao.class;
    }
    @Override
    public boolean isSingleton(){
        return true;
    }
}

默认创建是工厂实例对象是单例的，此时可不写isSingleton()方法，若需禁用则需重写isSingleton()方法。

配置实例工厂

$ vim resources/applicationContext.xml

Bean的生命周期

生命周期指的是从创建到消亡的完整过程，Bean的生命周期也就是从Bean的创建到销毁的完整过程，而Bean生命周期控制指的是在Bean创建后到销毁前做的一些事情。

初始化容器：创建对象（内存分配）-> 执行构造方法 -> 执行属性注入（set操作）-> 执行Bean初始化方法

Bean生命周期控制可采用两种方式

  • 提供生命周期控制方法，配置生命周期控制方法。
  • 实现InitializingBean和DisposableBean接口

例如：为Bean配置初始化执行方法和销毁时执行方法

为对应的类添加配置的方法

public class BaseDaoImpl implements BaseDao {
    public void init(){
        System.out.println("BASE DAO IMPL INIT...");
    }
    public void destroy(){
        System.out.println("BASE DAO IMPL DESTROY...");
    }
}

Bean正常销毁需要在容器关闭是才会触发

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

然而ApplicationContext类中并没有提供关闭容器的方法，ClassPathXmlApplicationContext类中提供了用于关闭容器的close方法（暴力方式）。

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
BaseDao bd1 = (BaseDao)ctx.getBean("baseDao");
BaseDao bd2 = (BaseDao)ctx.getBean("baseDao");
System.out.println(bd1);//com.jc.dao.impl.BaseDaoImpl@2f686d1f
System.out.println(bd2);//com.jc.dao.impl.BaseDaoImpl@3fee9989
System.out.println(bd1==bd2);//false
ctx.close();

此时查看打印信息

BASE DAO IMPL INIT...
com.jc.dao.impl.BaseDaoImpl@7085bdee
com.jc.dao.impl.BaseDaoImpl@7085bdee
true
BASE DAO IMPL DESTROY...

直接使用close()方法关闭容器相对比较暴力，优雅地做法的采用关闭钩子的方式。

设置registerShutdownHook容器关闭钩子，容器启动后添加一个标记，当虚拟机退出时根据标记判断是否关闭容器。

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
ctx.registerShutdownHook();
BaseDao bd1 = (BaseDao)ctx.getBean("baseDao");
BaseDao bd2 = (BaseDao)ctx.getBean("baseDao");
System.out.println(bd1);//com.jc.dao.impl.BaseDaoImpl@2f686d1f
System.out.println(bd2);//com.jc.dao.impl.BaseDaoImpl@3fee9989
System.out.println(bd1==bd2);//false

Spring为简化并统一Bean生命周期的控制，若不生工指定init-method和destroy-method数量。可直接在对应Bean的类中实现Spring接口：InitializingBean, DisposableBean来完成Bean生命周期的控制。

  • InitializingBean接口提供了afterPropertiesSet方法
  • DisposableBean接口提供了destroy方法
$ vim service/impl/BaseServiceImpl.java

public class BaseServiceImpl implements BaseService, InitializingBean, DisposableBean {
    private BaseDaoImpl baseDao;

    public void setBaseDao(BaseDaoImpl baseDao) {
        this.baseDao = baseDao;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("BASE SERVICE IMPL START PROPERTIES SET...");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("BASE SERVICE IMPL DESTROY...");
    }
}

运行测试

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
ctx.registerShutdownHook();
BaseService bs = (BaseService) ctx.getBean("baseService");
System.out.println(bs);

BASE DAO IMPL INIT...
BASE SERVICE IMPL START PROPERTIES SET...
com.jc.service.impl.BaseServiceImpl@6fd02e5
BASE SERVICE IMPL DESTROY...
BASE DAO IMPL DESTROY...

依赖注入（DI）

如何向一个类中传递数据呢？只有一种方式就是通过方法参数来传递数据。使用方法参数时根据方法可分为两种：一种是普通方法即采用setter方法来传递，另一种是采用构造方法来传递数据。

依赖注入描述了在容器中建立Bean与Bean之间依赖关系的过程，如果Bean运行需要的是数字或字符串，该怎么办呢？因此依赖注入时根据传递数据类型的不同可划分为两种：一种是引用类型、一种是简单类型（包含基础数据类型和String）

综上所述，依赖注入最终可分为4种方式

依赖注入 普通方法(setter方法) 构造方法（构造器）
简单数据类型 使用setter方法传递简单类型 使用构造方法传递简单类型
引用数据类型 使用setter方法传递引用类型 使用构造方法传递引用类型

依赖注入方法的选择

  • 强制依赖：采用构造器注入（严谨）
  • 可选依赖：采用Setter注入灵活性强，使用Setter注入有概率发生无法注入将导致null对象出现。

Spring框架推荐使用构造器注入，第三方框架内部大多采用构造器注入的方式实现数据初始化。

若有必要两者可同时使用，使用构造器注入强制依赖，使用Setter注入可选依赖。

自己开发模块推荐使用Setter注入，别人开发的模块若受控对象没有提供Setter方法就只能使用构造器注入。

setter注入引用类型

  • 在Bean中定义引用类型属性并提供可访问的Setter方法
public class BaseServiceImpl implements BaseService {
    private BaseDaoImpl baseDao; // ref="baseDao"
    public void setBaseDao(BaseDaoImpl baseDao) {
        this.baseDao = baseDao;
    }
}
  • 使用时在Bean配置中是用标签的ref属性来注入引用类型对象

setter注入简单类型

  • 在Bean中定义简单类型属性并提供可访问的Setter方法
public class BaseDaoImpl implements BaseDao {
    private Long appId;
    private String appKey;
    public void setAppId(Long appId){
        this.appId = appId;
    }
    public void setAppKey(String appKey){
        this.appKey = appKey;
    }
}

配置中是用标签的value属性来注入简单类型数据

构造器注入

配置构造器注入标签，其中name属性对应构造器形参名称，value对应参数值。

构造器注入简单类型

public class BaseDaoImpl implements BaseDao {
    private Long appId;
    private String appKey;
    public BaseDaoImpl(Long appId, String appKey){
        this.appId = appId;
        this.appKey = appKey;
    }
}

构造器注入引用类型

public class BaseServiceImpl implements BaseService {
    private BaseDao baseDao;
    public BaseServiceImpl(BaseDao baseDao){
        this.baseDao = baseDao;
    }
}

问题：由于标签中name属性必须与构造器中形参名称保持一致，相当于紧耦合，不便于修改调整。为了解决形参名称耦合问题，可去掉name属性替换为type属性，即根据指定的数据类型来识别出形参。

使用type属性虽然能解决name属性带来的耦合问题，但如果出现相同类型的形参，该怎么办呢？为了解决这种问题，可使用index属性即指定形参的索引位置，这样上面问题都可以得到解决。

依赖自动装配（autowire）

IoC容器根据Bean所依赖的资源，在容器内自动查找并注入到Bean中的过程，称为自动装配。

自动装配方式 说明
按类型 autowire="byType"
按名称 autowire="byName"
按构造方法 autowire="contructor"
禁用 autowire="no"

自动装配只需在Bean标签上添加autowire属性来设置自动装配的类型


public class BaseServiceImpl implements BaseService {
    private int[] array;
    public void setArray(int[] array){
        this.array = array;
    }

    private List list;
    public void setList(List list){
        this.list = list;
    }

    private Set set;
    public void setSet(Set set){
        this.set = set;
    }

    private Map map;
    public void setMap(Map map){
        this.map = map;
    }

    private Properties propertis;
    public void setProperties(Properties propertis){
        this.propertis = propertis;
    }
}

配置


        
                
                        1
                        2
                        3
                
        
        
                
                        v1
                        v2
                        v3
                
        
        
                
                        s1
                        s2
                        s3
                
        
        
                
                        
                        
                        
                
        
        
                
                        v1
                        v2
                        v3

管理数据源对象（连接池对象）

示例：管理阿里的Druid数据源对象

添加依赖并加载

$ vim pom.xml


    com.alibaba
    druid
    1.2.8

在Bean配置文件中管理DruidDataSource对象

从容器中读取

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
ctx.registerShutdownHook();
DataSource ds = (DataSource) ctx.getBean("dataSource");
System.out.println(ds);

示例：管理C3PO数据源对象

访问 https://mvnrepository.com/ 查找C3P0 库的坐标参数，添加到pom.xml中。


    mysql
    mysql-connector-java
    8.0.30


    c3p0
    c3p0
    0.9.1.2

查找到c3p0的数据源对象名称后配置Bean

从容器中获取Bean

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
ctx.registerShutdownHook();
DataSource ds = (DataSource) ctx.getBean("comboPooledDataSource");
System.out.println(ds);

加载Properties文件

Spring加载外部Properties文件之前，要开启一个全新的命名空间context。

添加context命名空间

xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
"

创建Properties属性配置文件

$ vim resources/jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/fw
jdbc.user=root
jdbc.password=root

使用context命名空间加载Properties配置文件

为避免加载的配置文件与系统配置同名造成自定义配置加载失败的问题，添加system-properties-mode="NEVER"属性来解决。

若自定义属性配置文件存在多个，可在location属性中使用逗号分割后加载多个。

可使用*.properties加载所有的后缀为.properties的配置文件

标准写法

使用classpath:*.properties写法只能从当前工程读取到自定义配置文件，若当前项目中添加的第三方jar包包含了自定义配置文件，则需要采用classpath*:*.properties写法。classpath*:*.properties表示不仅可以从当前项目中读取，也可以从所依赖的第三方jar中读取自定义的属性配置文件。

使用属性占位符${}读取properties文件中的属性

容器

创建容器

加载类路径下的配置 ，ClassPathXmlApplicationContext支持同时加载多个配置。

ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

也可以采用从文件系统下加载配置文件，这种方式需要采用配置文件的完整路径。

ApplicationContext ctx = new FileSystemXmlApplicationContext("E:\\java\\sl\\src\\main\\resources\\applicationContext.xml");

早期的创建容器也可采用BeanFactory来实现，BeanFactory创建完毕后所有Bean都是延迟加载的。

Resource r = new ClassPathResource("applicationContext.xml");
BeanFactory ctx = new XmlBeanFactory(r);

获取Bean

  • 使用Bean的名称获取
DataSource ds = (DataSource) ctx.getBean("comboPooledDataSource");
  • 使用Bean名称获取并指定类型
DataSource ds = ctx.getBean("comboPooledDataSource", DataSource.class);
  • 使用Bean类型获取
DataSource ds = ctx.getBean(DataSource.class);

总结

  • BeanFactory是IoC容器的顶层接口，初始化BeanFactory对象时加载的Bean采用的是延迟加载。
  • ApplicationContext接口是Spring容器的核心接口，初始化时Bean采用的立即加载。
  • ApplicationContext接口提供了基础的Bean操作方法，通过其他接口扩展其功能。
  • ApplicationContext接口常用初始化类包括：ClassPathXmlApplicationContext、FileSystemXmlApplicationContext

注解开发

注解开发定义Bean

  • 使用@Component注解来定义Bean
@Component("baseDao")
public class BaseDaoImpl implements BaseDao {
}
  • 核心配置文件中通过组件扫描来加载Bean

Spring为@Component注解提供了三个衍生注解

@Component衍生 说明
@Controller 用于表现层Bean定义
@Service 用于业务层Bean定义
@Repository 用于数据层Bean定义

纯注解开发

Spring3.0升级了纯注解开发模式，使用Java类替代配置文件开启了Spring快速开发赛道。

使用Java类代替Spring核心配置文件

$ vim config/SpringConfig.java

@Configuration
@ComponentScan("com.jc")
public class SpringConfig {

}
  • Configuration注解用于设定当前类为配置类
  • ComponentScan注解用于设定扫描路径，它只能添加一次，支持多个数据（数组格式）。

使用纯注解开发后，读取Spring核心配置文件初始化容器对象，需切换为读取Java配置类初始化容器对象。

ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
BaseDao bd = ctx.getBean(BaseDao.class);
System.out.println(bd);

Bean管理

  • Bean作用范围：使用@Scope定义Bean的作用范围
  • Bean生命周期：使用@PostConstruct和@PreDestroy定义Bean的生命周期

例如：

@Repository("baseDao")
@Scope("singleton")
public class BaseDaoImpl implements BaseDao {
    @PostConstruct
    public void init(){
        System.out.println("BASE DAO IMPL INIT...");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("BASE DAO IMPL DESTROY...");
    }
}

测试运行结果

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
//ctx.registerShutdownHook();
BaseDao bd1 = ctx.getBean(BaseDao.class);
BaseDao bd2 = ctx.getBean(BaseDao.class);
System.out.println(bd1);
System.out.println(bd2);
System.out.println(bd1 == bd2);
ctx.close();

依赖注入

自动装配

  • 使用@Autowired注解开启自动装配模式，默认采用的按类型注入（byType）。
  • @Autowired自动装配是基于反射设计创建对象，并暴力反射对应属性为私有属性来初始化数据，因此无需提供Setter方法。
  • @Autowired自动装配建议默认使用无参构造方法创建对象，若没有提供对应的构造方法则需提供唯一的构造方法。
@Service("baseService")
public class BaseServiceImpl implements BaseService {
    @Autowired
    private BaseDao baseDao;
}
  • 使用@Qualifier注解开启指定名称装配Bean，@Qualifier注解无法单独使用必须配合@Autowired注解使用。
@Service("baseService")
public class BaseServiceImpl implements BaseService {
    @Autowired
    @Qualifier("baseDao")
    private BaseDao baseDao;
}

@Repository("baseDao")
@Scope("singleton")
public class BaseDaoImpl implements BaseDao {
    @PostConstruct
    public void init(){
        System.out.println("BASE DAO IMPL INIT...");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("BASE DAO IMPL DESTROY...");
    }
}
  • 可使用@Value注解实现简单类型注入
public class BaseDaoImpl implements BaseDao {
    @Value("test")
    private String name;
}

使用使用外部配置文件作为值设置到@Value注解中呢？

  • 加载Properties文件

使用@PropertySource注解加载外部属性文件，@PropertySource路径仅支持单一文件配置，多文件需使用数组格式配置，禁止使用通配符*。

@Configuration
@ComponentScan("com.jc")
@PropertySource("jdbc.properties")
public class SpringConfig {

}

外部属性文件加载成功后，即可在@Value中直接使用指定属性值。

@Repository("baseDao")
@Scope("singleton")
public class BaseDaoImpl implements BaseDao {
    @Value("${jdbc.driver}")
    private String name;
}

管理第三方Bean

使用@Bean配置第三方Bean

$ vim config/SpringConfig.java

@Configuration
public class SpringConfig {
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        //ds.setDriverClassName();
        //ds.setUrl();
        //ds.setUsername();
        //ds.setPassword();
        return ds;
    }
}

退浆将第三方配置类独立封装后载入到主配置文件中

$ vim config/JdbcConfig.java

public class JdbcConfig {
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        //ds.setDriverClassName();
        //ds.setUrl();
        //ds.setUsername();
        //ds.setPassword();
        return ds;
    }
}

在主配置文件内通过@import标注手工导入到配置类的核心配置中，@import注解只能添加一次，若存在多个待导入项目则需使用数组格式。

$ vim config/SpringConfig.java

@Configuration
@Import({JdbcConfig.class})
public class SpringConfig {

}

将独立的配置类加入到核心配置，也可以使用@ComponentScan({"com.jc.config"})注解扫描配置类所在的包，来加载对应的配置类信息。此种方法不推荐。

独立的配置类中对简单类型，可直接采用@Value注解获取注入。

$ vim config/JdbcConfig.java

@PropertySource("jdbc.properties")
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driverClassName);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }
}

独立配置类中若存在引用类型，主要为Bean定义的方法设置形参即可，容器会根据类型自动装载对象。

Spring整合MyBatis

Spring整合MyBatis核心在于两个Bean，分别是SqlSessionFactoryBean和MapperScannerConfigurer。

MyBatis程序核心对象分析

步骤 说明
1 加载MyBatis配置文件
2 创建SqlSessionFactoryBuilder对象
3 创建SqlSessionFactory对象
4 获取SqlSession对象
5 SqlSession对象执行查询获取结果集
6 释放资源 
// 加载MyBatis配置文件
InputStream is = null;
try {
    is = Resources.getResourceAsStream("mybatis-config.xml");
} catch (IOException e) {
    e.printStackTrace();
}
//创建SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();
//创建SqlSessionFactory对象
SqlSessionFactory ssf = ssfb.build(is);
//获取SqlSession对象
SqlSession ss = ssf.openSession();
//SqlSession对象执行查询获取结果集
SysUserMapper m = ss.getMapper(SysUserMapper.class);
List l = m.list();
System.out.println(l);
//释放资源
ss.close();

Spring整合MyBatis时是围绕着核心对象SqlSessionFactory展开的

$ vim resources/jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/fw
jdbc.username=root
jdbc.password=root

$ vim resources/mybatis-config.xml

Spring整合MyBatis需添加两个依赖分别是spring-jdbc和mybatis-spring


    org.springframework
    spring-jdbc
    5.3.23


    org.mybatis
    mybatis-spring
    2.0.7

使用注解的方式开发，替换掉原来的mybatis-config.xml文件。

创建Spring核心配置，并导入JDBC与MyBatis配置。

$ vim config/SpringConfig.java

@Configuration
@ComponentScan("com.jc")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class, MybatisConfig.class})
public class SpringConfig {

}

创建JDBC配置文件，并添加Druid数据源配置项目。

$ vim config/JdbcConfig.java

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driverClassName);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }
}

创建MyBatis配置文件，使用sqlSessionFactory和mapperScannerConfigurer替换mybatis-config.xml中的内容。

$ vim config/MybatisConfig.java

public class MybatisConfig{
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource ds){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.jc.domain");
        ssfb.setDataSource(ds);
        return ssfb;
    }
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.jc.mapper");
        return msc;
    }
}

Spring整合JUnit

  • 关键点：配置@RunWith(SpringJUnit4ClassRunner.class)和@ContextConfiguration(classes = SpringConfig.class)

配置junit和spring-test两个依赖


    junit
    junit
    4.12
    test


    org.springframework
    spring-test
    5.3.23

在测试包下创建测试文件

$ vim AccountServiceTest.java

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;

    @Test
    public void testGetById(){
        System.out.println(accountService.getById(11));
    }
}

你可能感兴趣的:(SpringIoC)

  • Spring Ioc 容器介绍 圣心 springrpcjava
    本章介绍Spring的控制反转（IoC）容器。SpringIoC容器和Bean简介容器概述Bean概述依赖Bean范围自定义Bean的性质Bean定义继承容器扩展点基于注释的容器配置类路径扫描和托管组件使用JSR330标准注释基于Java的容器配置环境抽象注册LoadTimeWeaverApplicationContext的其他功能BeanFactoryAPI该接口表示SpringIoC容器，并负
  • Spring Framework技术学习 小码快撩 springjava
    导语在Java开发领域，SpringFramework无疑是一个里程碑式的存在。它提供了全面的编程和配置模型，帮助开发者解决企业级应用开发的复杂性。本文将引导读者深入了解SpringFramework的核心概念、主要特性和使用方法，并通过示例代码展示其在实际项目中的应用。一、SpringIoC（InversionofControl，控制反转）SpringIoC（InversionofControl
  • MyBatis框架与spring框架整合 李恩11 mybatisspringjava
    MyBatis—Spring项目目前大部分的Java互联网项目，都是用SpringMVC+Spring+MyBatis搭建平台的。使用SpringIoC可以有效的管理各类的Java资源，达到即插即拔的功能；通过SpringAOP框架，数据库事务可以委托给Spring管理，消除很大一部分的事务代码，配合MyBatis的高灵活、可配置、可优化SQL等特性，完全可以构建高性能的大型网站。毫无疑问，MyB
  • spring ioc是做什么的？ gb4215287 javaspringlog4jjava
    Spring框架的IOC（InversionofControl，控制反转）是Spring框架的一个核心特性，它主要解决的是对象管理和依赖管理的问题。下面我将简要解释SpringIOC的主要作用：什么是SpringIOC？控制反转：这是一种设计原则，目的是减少代码之间的耦合度。在Spring中，IOC意味着将对象的控制权转移给Spring框架。这意味着对象的创建、配置和管理都由Spring容器负责。
  • 如何使用Spring IOC的注解进行开发 李李世界爱学Java springjava后端
    目录1、如何使用注解标记和扫描2、如何使用注解配置作用域和周期方法3、如何使用注解进行引用类型自动装配4、如何使用注解对基本类型属性赋值SpringIoC（InversionofControl，控制反转）容器通过注解提供了一种简洁且强大的方式来进行依赖注入和配置管理。注解开发使得Spring应用程序的配置更为简洁和直观，减少了XML配置的冗余和复杂性。注解本身并不能执行，注解本身仅仅只是做一个标记
  • java3-5年面试题——框架篇 若久2023 javaspring
    -----Spring------1.springIOC的理解springioc指的是控制反转，IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。交由Spring容器统一进行管理，从而实现松耦合注入对象：构造方法注入、stter方法注入、接口注入2.spring是如何通过xml配置或者注解配置生成实例对象的？简单实列：将对象放入SpringIOC容器中。1.配置文件方式：ap
  • Spring Boot获取Bean的三种方式 Deh0rs JavaSpringBoot实战springbootjava后端数据库前端开发语言spring
    博客主页:南来_北往系列专栏：SpringBoot实战引言在SpringBoot中，Bean是一个由SpringIoC容器管理的对象。SpringBean是在SpringIoC容器中被实例化、组装和管理的对象，可以视为Spring应用的构建块。它通过提供一套丰富的注解和配置方式，极大地简化了Java应用的开发过程，特别是对于依赖注入和AOP等高级特性的支持，使得代码更加简洁且易于维护。实战在Spr
  • Spring（面试篇） 在无清风 面试篇spring面试java
    目录什么是Spring？Spring的两大核心概念Spring框架的设计目标，设计理念，和核心是什么Spring的优缺点是什么？Spring由哪些应用场景Spring由哪些模块组成？Spring框架中都用到了那些设计模式？Spring应用程序有哪些不同组件？Spring控制反转（IOC）什么是SpringIOC容器？控制反转（IOC）有什么作用IOC的优点是什么？什么是Spring的依赖注入依赖注
  • Spring（概念） lvpflv spring源码springpythonjava
    1、企业级应用Spring之所以称为容器，就是由于BeanFactory的自动装配和注入Spring3开始把jar拆分成了多个：spring2及Spring2之前只有一个jar包2、SpringIOC简介和环境搭建责任链缺点：层与层之间的相互调用造成了耦合性比较高解决方案：SpringIOC控制反转项目应用场景、帮助创建SqlSessionFactory、管理所有Mapper接口，管理所有Serv
  • Spring AOP 源码分析 平凡的柚子
    寻找入口Spring的AOP是通过接入BeanPostProcessor后置处理器开始的，它是SpringIOC容器经常使用到的一个特性，这个Bean后置处理器是一个监听器，可以监听容器触发的Bean声明周期事件。后置处理器向容器注册以后，容器中管理的Bean就具备了接收IOC容器事件回调的能力。1、BeanPostProcessor源码publicinterfaceBeanPostProcess
  • 零基础学JavaWeb开发（十八）之 spring框架（1） 出世&入世 JavaJavaWebspringjava代理模式学习web
    spring框架1、Spring介绍1.1、Spring概念Spring是一个JavaEE开源的轻量级别的框架，可以解决我们企业开发中遇到的难题，能够让编码变的更加简单，核心组件IOC容器和Aop面向切面编程。1.IOC控制反转：把整个对象创建的过程，统一交给我们SpringIOC容器来实现管理，底层使用反射+工厂模式实现。2.Aop面向切面编程：对我们功能（方法）前后实现增强，比如打印日志、事务
  • 【Spring】IoC容器 控制反转 与 DI依赖注入 概念 第一期 道格维克 后端#Springspringjava后端
    文章目录Spring和SpringFramework概念一、SpringIoC容器核心概念1.1组件和组件管理概念1.2SpringIoC容器和容器实现1.2.1普通和复杂容器1.2.2SpringIoC容器介绍1.2.3SpringIoC容器具体接口和实现类1.2.4SpringIoC容器管理配置方式1.3SpringIoC/DI概念总结二、SpringIoC/DI实现步骤简略2.1配置文件2.
  • 【SpringBoot3】Spring Security 核心概念 顽石九变 SpringBoot3.0从入门到精通springjavaSpringBootspringsecurity
    一、什么是SpringSecurity注：本文基于SpringBoot3.2.1以及SpringSecurity6.2.1SpringSecurity是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了SpringIoC、DI（依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问
  • Spring IoC 依赖注入的三种方式 swadian2008 Springspringspringioc依赖注入
    目录1、什么是SpringIoC?2、SpringIoC注入的三种方式（1）构造方法注入（2）setter方法注入（3）接口注入IoC原则对应：好莱坞原则Don’tcallus,wewillcallyou1、什么是SpringIoC?SpringIoC（InversionofControl，控制反转）是一种设计原则，也是一种编程思想。IoC的核心思想是将对象的创建和对象之间的依赖关系的管理交由容器
  • Spring ——Spring IoC容器详解（图示） 云源 springjava
    1.1SpringIoC容器从昨天的例子当中我们已经知道springIoC容器的作用，它可以容纳我们所开发的各种Bean。并且我们可以从中获取各种发布在SpringIoC容器里的Bean，并通过描述得到它。1.2SpringIoC容器的设计SpringIoC容器的设计主要是基于BeanFactory和ApplicationContext两个接口，其中ApplicationContext是BeanF
  • Spring源码笔记之SpringIOC--（3）什么是BeanFactory？ 冷雨夜中漫步 spring全家桶spring笔记java
    什么是BeanFactory？BeanFactory是SpringIOC的最顶层接口，涵盖了IOC容器最基本的操作。ListableBeanFactory、ConfigurableBeanFactory提供了IOC容器获取所有Bean、配置Bean的额外能力。所有BeanFactory的实现类持有所有Bean的定义BeanDefinition，用一个唯一的字符串（即Bean的名字）区分。BeanF
  • Spring IoC依赖查找 技术路上的绊脚石
    SpringIoC依赖查找类型如下：根据Bean名称（id）查找，在Spring的一个上下文中，名称（id）必须唯一实时查找：马上查找，马上所得延迟查找注：spring应用可以有多个上下文BeanFactorybeanFactory=newClassPathXmlApplicationContext("classpath:/dependency/lookupDemo.xml");//实时查找loo
  • Spring Bean的生命周期 程序员小潘 Springspringjava后端
    前言SpringBean是SpringIOC容器负责实例化、组装和管理的对象，它和普通的Java对象并没有什么区别，唯一的区别就是它不是由开发人员自己new出来的，而是由容器负责创建的。IOC容器除了实例化对象，还会负责管理对象之间的依赖关系，自动注入依赖和属性，甚至创建代理对象来对原始对象进行增强。生命周期是一个对象从创建到被销毁经历的整个过程，普通Java对象的生命周期是JVM分配内存，调用构
  • 学习记录691@spring面试之bean的作用域 教练 我想学编程 学习spring面试
    Spring为Bean定义了5种作用域，分别为Singleton（单例）、Prototype（原型）、Request（请求级别）、Session（会话级别）和GlobalSession（全局会话）。SingletonSingleton是单例模式，当实例类型为单例模式时，SpringIoC容器中只会存在一个共享的Bean实例，无论有多少个Bean引用它，都始终指向同一个Bean对象。该模式在多线程下
  • Spring IoC容器详解 谷哥的小弟 SpringSpringIoC容器Spring容器Java框架SpringBoot
    版权声明本文原创作者：谷哥的小弟作者博客地址：http://blog.csdn.net/lfdfhl基本概念SpringIoC容器是Spring框架的核心组件，它实现了控制反转（InversionofControl，IoC）的设计原则。IoC是一种编程思想，它将原本由代码直接操控的对象调用权交给第三方（即SpringIoC容器）来控制，以解耦代码，提高程序的可维护性和可扩展性。核心功能Spring
  • XmlBeanFactory和ApplicationContext的区别 onlyHalfSoul
    BeanFactoryBeanFactory是Spring的“心脏”。它就是SpringIoC容器的真面目。Spring使用BeanFactory来实例化、配置和管理Bean。BeanFactory：是IOC容器的核心接口，它定义了IOC的基本功能，我们看到它主要定义了getBean方法。getBean方法是IOC容器获取bean对象和引发依赖注入的起点。方法的功能是返回特定的名称的Bean。Be
  • 【Java万花筒】解析Java依赖注入：从Spring到CDI的全方位比较 friklogff Java万花筒javaspring
    探索Java依赖注入：框架、实践与比较前言在当今的软件开发中，依赖注入已经成为了一种不可或缺的设计模式。Java作为一种广泛应用的编程语言，在依赖注入领域也有着丰富的框架和实践。本文将探索Java中几种常用的依赖注入框架，包括SpringIoC、GoogleGuice、PicoContainer、Dagger、HK2和CDI，介绍它们的特点、用法以及适用场景，帮助读者更好地理解和选择合适的依赖注入
  • SpringIOC之support模块ResourceBundleMessageSource 卡布奇诺-海晨 Spring家族及微服务系列javaspring
    博主介绍：✌全网粉丝5W+，全栈开发工程师，从事多年软件开发，在大厂呆过。持有软件中级、六级等证书。可提供微服务项目搭建与毕业项目实战，博主也曾写过优秀论文，查重率极低，在这方面有丰富的经验✌博主作品：《Java项目案例》主要基于SpringBoot+MyBatis/MyBatis-plus+MySQL+Vue等前后端分离项目，可以在左边的分类专栏找到更多项目。《Uniapp项目案例》有几个有un
  • 工作常用的Spring依赖注入和Bean的装配问题，今天给大家讲清楚！ 码上入坟
    写在前面小伙伴儿们，虽然现在Springboot使用的已经非常广泛了，但是Spring依然有很多公司在使用，Spring的依赖注入以及Bean的装配是面试常问的知识点，今天我们来学习一下Spring中的依赖注入方式，以及如何将自己开发的Bean装配到SpringIoC容器中。思维导图图片1、依赖注入方式1.1、setter注入；setter注入是Spring中最主流的注入方式，它利用JavaBea
  • 万字详解带你手撕 Spring 5:00A.M ssmspring
    Spring万字详解SpringIOC1.IOC底层原理2.画图讲解IOC底层原理3.IOC(接口)4.IOC操作(Bean管理)4.1什么是Bean管理4.2基于xml配置文件方式操作Bean对象set方式注入有参构造注入xml注入其他类型属性属性注入-外部bean属性注入-内部bean属性注入-级联赋值xml注入集合属性4.3FactoryBean4.4bean的作用域4.5bean的生命周期
  • 16.1 Spring框架_SpringIoC容器与Bean管理(❤❤) 与海boy Java工程师(后端开发)springjava后端
    16.1Spring框架_SpringIoC容器与Bean管理1.Spring1.1SpringIoC1.IoC控制反转2.DI依赖注入1.2Spring概念1.Spring含义2.传统开发与SpringIoC开发模式比较2.IoC基础实现案例(❤❤)1.传统方式2.IoC与DI方式3.bean管理:基于XML配置Bean(❤❤)3.1基础配置3.2beanid与name属性<
  • 常见几种设计模式之模板模式 我shi杰迷
    目录一、创建型1.单例模式2.工厂模式3.原型模式二、结构型1.享元模式2.代理模式三、行为型1.模板模式(1)模板模式-制作豆浆(2)钩子方法-制作豆浆(3)SpringIOC初始化(4)总结2.职责链模式(1)模板模式-制作豆浆1.项目介绍(1)制作豆浆流程:选材料==>添加材料==>浸泡==>放到豆浆机打碎(2)这些流程对于制作红豆豆浆,花生豆浆得流程是一样的,所以可以考虑使用模板方法模式2
  • Spring IoC容器详解 谷哥的小弟 SpringspringjavaSpringBoot源码框架
    版权声明本文原创作者：谷哥的小弟作者博客地址：http://blog.csdn.net/lfdfhl基本概念SpringIoC容器是Spring框架的核心组件，它实现了控制反转（InversionofControl，IoC）的设计原则。IoC是一种编程思想，它将原本由代码直接操控的对象调用权交给第三方（即SpringIoC容器）来控制，以解耦代码，提高程序的可维护性和可扩展性。核心功能Spring
  • 高频面试真题答案 -java后端 -java框架篇 qq_46529610 高频面试真题答案-java后端java面试后端
    原贴：2022届秋招高频面试真题汇总，千题奉送！！！-后端篇_笔经面经_牛客网整理答案：SpringAOP的底层原理51SpringBean的生命周期31Spring中IOC的底层原理28Spring如何解决循环依赖22spring的动态代理模式14Spring使用了哪些设计模式？9springioc的设计思想和好处8简述为什么要使用Spring？(Spring优势)6简述Spring事务6spr
  • SpringIOC之support模块ReloadableResourceBundleMessageSource 卡布奇诺-海晨 Spring家族及微服务系列springjavaspringboot
    博主介绍：✌全网粉丝5W+，全栈开发工程师，从事多年软件开发，在大厂呆过。持有软件中级、六级等证书。可提供微服务项目搭建与毕业项目实战，博主也曾写过优秀论文，查重率极低，在这方面有丰富的经验✌博主作品：《Java项目案例》主要基于SpringBoot+MyBatis/MyBatis-plus+MySQL+Vue等前后端分离项目，可以在左边的分类专栏找到更多项目。《Uniapp项目案例》有几个有un
  • 插入表主键冲突做更新 a-john
    有以下场景： 用户下了一个订单，订单内的内容较多，且来自多表，首次下单的时候，内容可能会不全（部分内容不是必须，出现有些表根本就没有没有该订单的值）。在以后更改订单时，有些内容会更改，有些内容会新增。 问题： 如果在sql语句中执行update操作，在没有数据的表中会出错。如果在逻辑代码中先做查询，查询结果有做更新，没有做插入，这样会将代码复杂化。 解决： mysql中提供了一个sql语
  • Android xml资源文件中@、@android:type、@*、？、@+含义和区别 Cb123456 @+@?@*
    一.@代表引用资源 1.引用自定义资源。格式：@[package:]type/name android：text="@string/hello"   2.引用系统资源。格式：@android:type/name     android:textColor="@android:color/opaque_red"
  • 数据结构的基本介绍 天子之骄 数据结构散列表树、图线性结构价格标签
    数据结构的基本介绍 数据结构就是数据的组织形式，用一种提前设计好的框架去存取数据，以便更方便，高效的对数据进行增删查改。正确选择合适的数据结构，对软件程序的高效执行的影响作用不亚于算法的设计。此外，在计算机系统中数据结构的作用也是非同小可。例如常常在编程语言中听到的栈，堆等，就是经典的数据结构。   经典的数据结构大致如下：   一：线性数据结构 (1)：列表 a
  • 通过二维码开放平台的API快速生成二维码 一炮送你回车库 api
     现在很多网站都有通过扫二维码用手机连接的功能，联图网(http://www.liantu.com/pingtai/)的二维码开放平台开放了一个生成二维码图片的Api,挺方便使用的。闲着无聊，写了个前台快速生成二维码的方法。        html代码如下:(二维码将生成在这div下) ? 1  &nbs
  • ImageIO读取一张图片改变大小 3213213333332132 javaIOimageBufferedImage
    package com.demo; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import javax.imageio.ImageIO; /** * @Description 读取一张图片改变大小 * @author FuJianyon
  • myeclipse集成svn（一针见血） 7454103 eclipseSVNMyEclipse
                                     &n
  • 装箱与拆箱----autoboxing和unboxing darkranger J2SE
    4.2　自动装箱和拆箱 基本数据(Primitive)类型的自动装箱(autoboxing)、拆箱(unboxing)是自J2SE 5.0开始提供的功能。虽然为您打包基本数据类型提供了方便，但提供方便的同时表示隐藏了细节，建议在能够区分基本数据类型与对象的差别时再使用。 4.2.1　autoboxing和unboxing 在Java中，所有要处理的东西几乎都是对象(Object)
  • ajax传统的方式制作ajax aijuans Ajax
    //这是前台的代码 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+
  • 只用jre的eclipse是怎么编译java源文件的？ avords javaeclipsejdktomcat
    eclipse只需要jre就可以运行开发java程序了，也能自动 编译java源代码，但是jre不是java的运行环境么，难道jre中也带有编译工具？ 还是eclipse自己实现的？谁能给解释一下呢问题补充：假设系统中没有安装jdk or jre，只在eclipse的目录中有一个jre，那么eclipse会采用该jre，问题是eclipse照样可以编译java源文件，为什么呢？ &nb
  • 前端模块化 bee1314 模块化
    背景： 前端JavaScript模块化，其实已经不是什么新鲜事了。但是很多的项目还没有真正的使用起来，还处于刀耕火种的野蛮生长阶段。   JavaScript一直缺乏有效的包管理机制，造成了大量的全局变量，大量的方法冲突。我们多么渴望有天能像Java（import），Python (import)，Ruby(require)那样写代码。在没有包管理机制的年代，我们是怎么避免所
  • 处理百万级以上的数据处理 bijian1013 oraclesql数据库大数据查询
    一.处理百万级以上的数据提高查询速度的方法：        1.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。         2.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 o
  • mac 卸载 java 1.7 或更高版本 征客丶 javaOS
    卸载 java 1.7 或更高 sudo rm -rf /Library/Internet\ Plug-Ins/JavaAppletPlugin.plugin 成功执行此命令后，还可以执行 java 与 javac 命令 sudo rm -rf /Library/PreferencePanes/JavaControlPanel.prefPane 成功执行此命令后，还可以执行 java
  • 【Spark六十一】Spark Streaming结合Flume、Kafka进行日志分析 bit1129 Stream
    第一步，Flume和Kakfa对接，Flume抓取日志，写到Kafka中 第二部，Spark Streaming读取Kafka中的数据，进行实时分析   本文首先使用Kakfa自带的消息处理（脚本）来获取消息，走通Flume和Kafka的对接 1. Flume配置 1. 下载Flume和Kafka集成的插件，下载地址：https://github.com/beyondj2ee/f
  • Erlang vs TNSDL bookjovi erlang
          TNSDL是Nokia内部用于开发电信交换软件的私有语言，是在SDL语言的基础上加以修改而成，TNSDL需翻译成C语言得以编译执行，TNSDL语言中实现了异步并行的特点，当然要完整实现异步并行还需要运行时动态库的支持，异步并行类似于Erlang的process（轻量级进程），TNSDL中则称之为hand，Erlang是基于vm(beam)开发，
  • 非常希望有一个预防疲劳的java软件, 预防过劳死和眼睛疲劳,大家一起努力搞一个 ljy325 企业应用
    　非常希望有一个预防疲劳的java软件，我看新闻和网站，国防科技大学的科学家累死了，太疲劳，老是加班，不休息，经常吃药，吃药根本就没用，根本原因是疲劳过度。我以前做java,那会公司垃圾，老想赶快学习到东西跳槽离开，搞得超负荷，不明理。深圳做软件开发经常累死人，总有不明理的人，有个软件提醒限制很好，可以挽救很多人的生命。 相关新闻： （1）IT行业成五大疾病重灾区：过劳死平均37.9岁
  • 读《研磨设计模式》-代码笔记-原型模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * Effective Java 建议使用copy constructor or copy factory来代替clone()方法： * 1.public Product copy(Product p){} * 2.publi
  • 配置管理---svn工具之权限配置 chenyu19891124 SVN
    今天花了大半天的功夫，终于弄懂svn权限配置。下面是今天收获的战绩。 安装完svn后就是在svn中建立版本库，比如我本地的是版本库路径是C:\Repositories\pepos。pepos是我的版本库。在pepos的目录结构 pepos    component    webapps 在conf里面的auth里赋予的权限配置为 [groups]
  • 浅谈程序员的数学修养 comsci 设计模式编程算法面试招聘
                                     浅谈程序员的数学修养
  • 批量执行 bulk collect与forall用法 daizj oraclesqlbulk collectforall
    BULK COLLECT 子句会批量检索结果，即一次性将结果集绑定到一个集合变量中，并从SQL引擎发送到PL/SQL引擎。通常可以在SELECT INTO、 FETCH INTO以及RETURNING INTO子句中使用BULK COLLECT。本文将逐一描述BULK COLLECT在这几种情形下的用法。     有关FORALL语句的用法请参考：批量SQL之 F
  • Linux下使用rsync最快速删除海量文件的方法 dongwei_6688 OS
    1、先安装rsync：yum install rsync 2、建立一个空的文件夹：mkdir /tmp/test 3、用rsync删除目标目录：rsync --delete-before -a -H -v --progress --stats /tmp/test/ log/这样我们要删除的log目录就会被清空了，删除的速度会非常快。rsync实际上用的是替换原理，处理数十万个文件也是秒删。
  • Yii CModel中rules验证规格 dcj3sjt126com rulesyiivalidate
    Yii cValidator主要用法分析：  yii验证rulesit 分类： Yii yii的rules验证 cValidator主要属性 attributes ,builtInValidators,enableClientValidation,message,on,safe,skipOnError  
  • 基于vagrant的redis主从实验 dcj3sjt126com vagrant
    平台: Mac 工具: Vagrant 系统: Centos6.5 实验目的: Redis主从   实现思路 制作一个基于sentos6.5, 已经安装好reids的box, 添加一个脚本配置从机, 然后作为后面主机从机的基础box   制作sentos6.5+redis的box   mkdir vagrant_redis cd vagrant_
  • Memcached(二)、Centos安装Memcached服务器 frank1234 centosmemcached
    一、安装gcc rpm和yum安装memcached服务器连接没有找到，所以我使用的是make的方式安装，由于make依赖于gcc，所以要先安装gcc 开始安装，命令如下，[color=red][b]顺序一定不能出错[/b][/color]： 建议可以先切换到root用户，不然可能会遇到权限问题：su root 输入密码...... rpm -ivh kernel-head
  • Remove Duplicates from Sorted List hcx2013 remove
    Given a sorted linked list, delete all duplicates such that each element appear only once. For example,Given 1->1->2, return 1->2.Given 1->1->2->3->3, return&
  • Spring4新特性——JSR310日期时间API的支持 jinnianshilongnian spring4
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • 浅谈enum与单例设计模式 247687009 java单例
    在JDK1.5之前的单例实现方式有两种(懒汉式和饿汉式并无设计上的区别故看做一种)，两者同是私有构 造器，导出静态成员变量，以便调用者访问。 第一种 package singleton; public class Singleton { //导出全局成员 public final static Singleton INSTANCE = new S
  • 使用switch条件语句需要注意的几点 openwrt cbreakswitch
    1. 当满足条件的case中没有break，程序将依次执行其后的每种条件（包括default）直到遇到break跳出 int main() { int n = 1; switch(n) { case 1: printf("--1--\n"); default: printf("defa
  • 配置Spring Mybatis JUnit测试环境的应用上下文 schnell18 springmybatisJUnit
    Spring-test模块中的应用上下文和web及spring boot的有很大差异。主要试下来差异有： 单元测试的app context不支持从外部properties文件注入属性 @Value注解不能解析带通配符的路径字符串 解决第一个问题可以配置一个PropertyPlaceholderConfigurer的bean。 第二个问题的具体实例是：    
  • Java 定时任务总结一 tuoni javaspringtimerquartztimertask
     Java定时任务总结  一.从技术上分类大概分为以下三种方式：  1.Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务;   说明：    java.util.Timer定时器，实际上是个线程，定时执行TimerTask类 &
  • 一种防止用户生成内容站点出现商业广告以及非法有害等垃圾信息的方法 yangshangchuan rank相似度计算文本相似度词袋模型余弦相似度
    本文描述了一种在ITEYE博客频道上面出现的新型的商业广告形式及其应对方法，对于其他的用户生成内容站点类型也具有同样的适用性。   最近在ITEYE博客频道上面出现了一种新型的商业广告形式，方法如下：     1、注册多个账号（一般10个以上）。     2、从多个账号中选择一个账号，发表1-2篇博文
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他