精华内容
下载资源
问答
  • Spring 多实例注入

    千次阅读 2020-02-22 12:37:28
    Spring 多实例注入的应用2. Spring 多实例注入的使用 1. Spring 多实例注入的应用 Spring 容器中保存的 bean 默认是单例的,通常来说这样做可以降低 bean 对象创建的频率,在某些访问量大的场景下可以节省对象创建...

    1. Spring 多实例注入的应用场景

    Spring 容器中保存的 bean 默认是单例的,通常来说这样做可以降低 bean 对象创建的频率,在某些访问量大的场景下可以节省对象创建消耗的时间,提高响应性能。但在一些其他场景,比如脚本调度处理多个消息队列中的消息,这时候拉取各个队列消息的步骤是完全相同的,只不过各条队列的名称和密码不一样,很明显可以使用一个专门的 processor来处理,以便减少重复代码。这样一来,一个解决方式是每一条队列使用一个单独的processor实例,这就需要用到 Spring 的多实例注入了

    2. Spring 多实例注入的使用

    Spring 框架中, 在一个Java 类上添加注解@Scope("prototype")即声明该类为原型作用域,每次通过 Spring 容器获取其实例的时候都会返回一个新的对象。但是要注意,声明为多实例的 bean 对象通过注解 @Resource@Autowired 自动注入是无法保证每次获取的都是新的实例的,一个解决方法是通过Spring 的 ApplicationContext,直接获取容器中的 bean 实例,示例代码如下

    1. 首先在目标类上添加注解@Scope("prototype")声明其每次使用都需要新的实例

      @Component
      @Scope("prototype")
      public class MessageProcessor {
         ......
         private String queueName;
         private String passWord;
         ......
      }
      
    2. 创建实现ApplicationContextAware 接口的 SpringBeanProvider工具类。使用时注入 SpringBeanProvider 实例,调用其 getBean()方法,传入指定参数即可获取到类的新实例

      @Component
      public class SpringBeanProvider implements ApplicationContextAware {
      
       private ApplicationContext applicationContext;
      
       @Override
       public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
           this.applicationContext = applicationContext;
      
       }
      
       /**
        * 通过 beanName 获取 Bean
        * @param beanName
        * @return
        */
       public Object getBean(String beanName) {
           return applicationContext.getBean(beanName);
       }
      
       /**
        * 通过class获取Bean
        * @param clazz
        * @param <T>
        * @return
        */
       public <T> T getBean(Class<T> clazz) {
           return applicationContext.getBean(clazz);
       }
      
       /**
        * 通过 beanName ,以及Clazz返回指定的Bean
        * @param beanName
        * @param clazz
        * @param <T>
        * @return
        */
       public <T> T getBean(String beanName, Class<T> clazz) {
           return applicationContext.getBean(beanName, clazz);
       }
      }
      
    展开全文
  • Spring定时任务,里面有实例,配置形式的 还有注解实现的,还有quartz和Spring实现的,希望对大家有用
  • Spring Batch 实例代码

    2012-11-08 14:34:38
    Spring Batch 实例代码
  • Spring-同个接口注入实例

    千次阅读 2019-09-04 20:46:49
    一般开发,都是一个接口对应一个实现类,但是有时候有些业务场景可能面临一个接口对应个实现类,这个时候如果直接使用@Autowire注入有可能就会报错,下面就把常用解决方法阐述一下:比如下面这个服务接口,就有个实现 ...

    一般开发,都是一个接口对应一个实现类,但是有时候有些业务场景可能面临一个接口对应多个实现类,这个时候如果直接使用@Autowire注入有可能就会报错,下面就把常用解决方法阐述一下:比如下面这个服务接口,就有多个实现

    //生产消息服务接口
    public interface IProducerService {}
    
    //使用kafak发送消息
    @Service("kafkaProducerService")
    @Log4j2
    public class KafkaProducerService  implements IProducerService {}
    
    //使用rabbitmq发送消息
    @Service("rabbitProducerService")
    @Log4j2
    public class RabbitProducerService implements IProducerService {}
    
    //使用rocketmq发送消息
    @Service("rocketProducerService")
    @Log4j2
    public class RocketProducerService implements IProducerService {}
    
    
    
    

    我们可以通过如下三种注入方式,完成多接口的实例注入

    1 使用@Autowired:service对象名要和beanName相同

        @Autowired
        private IProducerService kafkaProducerService;
    
        @Autowired
        private IProducerService rocketProducerService;
    
        @Autowired
        private IProducerService rabbitProducerService;
    

    2 使用 @Resource:注入的name的名称要和service的对象名要一致

        @Resource(name = "kafkaProducerService")
        private IProducerService kafkaProducerService;
    
        @Resource(name = "rocketProducerService")
        private IProducerService rocketProducerService;
    
        @Resource(name = "rabbitProducerService")
        private IProducerService rabbitProducerService;

    3 使用 @Autowired + @Qualifier

    
        @Qualifier(value = "kafkaProducerService")
        @Autowired
        private IProducerService getKafkaProducerService;
    
        @Qualifier(value = "rocketProducerService")
        @Autowired
        private IProducerService getRocketProducerService;
    
        @Qualifier(value = "rabbitProducerService")
        @Autowired
        private IProducerService getRabbitProducerService;

    下一次会介绍如何通过条件进行动态匹配实例的创建

    展开全文
  • Spring Cloud项目实例

    2018-01-23 09:18:14
    Spring Cloud项目实例,包括注册,负载配置,分布式配置,网关及调用
  • (1)在配置完spring提示框架后(上一遍文章有介绍),首先创建一个项目,导入sprig所需的jar包然后书写主配置文件applicationContext.&lt;?xml version="1.0" encoding="UTF-8"?&gt; &...

    (1)在配置完spring提示框架后(上一遍文章有介绍),首先创建一个项目,导入sprig所需的jar包


    然后书写主配置文件applicationContext.

    <?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
               http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
               
               
               <!-- bean:将一个类的对象创建过程交给spring容器
                         class:指定类的具体路径
                         id:唯一标识符
                     -->
               <bean id="yellowMouseWolf" class="cn.java.ioc1.YellowMouseWolf" ></bean>
      
    </beans>
    
    
    
    

    又创建了一个window类,用来测试:

    package cn.java.ioc1;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Window {
    
    	public static void main(String[] args) {
    		//启动框架(context代表spring容器)
    		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");//只写这句也可以调用YellowMouseWolf类中的无参构造方法
             //获取spring容器中创建的对象(通过id值获取)
    		YellowMouseWolf yello1=(YellowMouseWolf)context.getBean("yellowMouseWolf");
    		yello1.behavior();
    		
    	}
    
    }
    
    package cn.java.ioc1;
    
    public class YellowMouseWolf {
    	
    	public YellowMouseWolf() {
    		System.out.println("YellowMouseWolf----黄鼠狼出生");
    		
    	}
    	
    	public void behavior() {
    		
    		System.out.println("吃鸡");
    		
    	}
    }
    

    如上便是一个简单的实例。

    (2)单例与多例

    创建一个Dog

    package cn.java.singleton2;
    
    public class Dog {
    
    	public Dog() {
    		System.out.println("一直狗狗诞生了");
    	}
    	public void behavior() {
    		System.out.println("狗会叫");
    		
    	}
    
    }
    

    配置文件,这里设置为多例

    <?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
               http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
               
               
               <!-- bean:将一个类的对象创建过程交给spring容器
                         class:指定类的具体路径
                         id:唯一标识符
                   scope:用来控制spring容器产生对象的方式,可以为单例也可以为多例。
                        常用的值为singleton(单例),prototype(多例),默认的是单例      
                    
                     -->
               <bean id="dog" class="cn.java.singleton2.Dog" scope="prototype" ></bean>
      
    </beans>
    
    
    
    
    
    
    

    创建一个调用的类

    package cn.java.ioc1;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import cn.java.singleton2.Dog;
    
    public class Window {
    
    	public static void main(String[] args) {
    		//启动框架(context代表spring容器)
    		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");//只写这句也可以调用YellowMouseWolf类中的无参构造方法
             //获取spring容器中创建的对象(通过id值获取)
    		Dog dog1=(Dog)context.getBean("dog");
    		Dog dog2=(Dog)context.getBean("dog");
    		Dog dog3=(Dog)context.getBean("dog");
    		//获得各自地址
    		System.out.println(dog1);
    		System.out.println(dog2);
    		System.out.println(dog3);
    		
    	}
    
    }
    

    这是多例的结果:


    dog1,dog2,dog3分别获得了数据,而且这三个的地址不同。

    这是单例的配置:

    <?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
               http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
               
               
               <!-- bean:将一个类的对象创建过程交给spring容器
                         class:指定类的具体路径
                         id:唯一标识符
                   scope:用来控制spring容器产生对象的方式,可以为单例也可以为多例。
                        常用的值为singleton(单例),prototype(多例),默认的是单例      
                    
                     -->
               <bean id="dog" class="cn.java.singleton2.Dog"  ></bean>
      
    </beans>
    
    
    
    结果如下:只输出一个数据,而且地址相同。


    (3)初始化

    先看配置信息

    <?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
               http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
               
               
               <!-- bean:将一个类的对象创建过程交给spring容器
                         class:指定类的具体路径
                         id:唯一标识符
                   scope:用来控制spring容器产生对象的方式,可以为单例也可以为多例。
                        常用的值为singleton(单例),prototype(多例),默认的是单例      
                    init-method:表示初始化方法,只写初始化方法的名字,不用加上();
                     -->
               <bean id="smallJi" class="cn.java.initAndDistroy.ji"  init-method="init"></bean>
      
    </beans>
    

    再看一个类:

    package cn.java.initAndDistroy;
    
    public class Ji {
    	public Ji() {
    		System.out.println("ji..........鸡出生了");
    	}
    	public void init() {
    		System.out.println("ji.......我是初始化方法");
    		
    	}
    	public void behavior() {
    		System.out.println("鸡会打鸣");
    		
    	}
    
    
    }
    

    以及一个调用类:

    package cn.java.ioc1;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import cn.java.initAndDistroy.Ji;
    import cn.java.singleton2.Dog;
    
    public class Window {
    
    	public static void main(String[] args) {
    		//启动框架(context代表spring容器)
    		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");//只写这句也可以调用YellowMouseWolf类中的无参构造方法
             //获取spring容器中创建的对象(通过id值获取)
    		Ji ji=(Ji)context.getBean("smallJi");
    		ji.behavior();
    		
    	}
    
    }
    
    结果如下:


    我们看出,先执行构造方法,然后执行的是初始化方法。

    销毁:

    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
               http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
               
               
               <!-- bean:将一个类的对象创建过程交给spring容器
                         class:指定类的具体路径
                         id:唯一标识符
                   scope:用来控制spring容器产生对象的方式,可以为单例也可以为多例。
                        常用的值为singleton(单例),prototype(多例),默认的是单例      
                    init-method:表示初始化方法,只写初始化方法的名字,不用加上();
    destroy-method是销毁方法。
    --> <bean id="smallJi" class="cn.java.initAndDistroy.ji" init-method="init" destroy-method="destroy"></bean> </beans>
    package cn.java.initAndDistroy;
    
    public class Ji {
    	public Ji() {
    		System.out.println("ji..........鸡出生了");
    	}
    	public void init() {
    		System.out.println("ji.......我是初始化方法");
    		
    	}
    	public void behavior() {
    		System.out.println("鸡会打鸣");
    		
    	}
    	//销毁
    	public void destroy() {
    		System.out.println("ji........鸡挂了");
    		
    	}
    
    
    }

    package cn.java.ioc1;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import cn.java.initAndDistroy.Ji;
    import cn.java.singleton2.Dog;
    
    public class Window {
    
    	public static void main(String[] args) {
    		//启动框架(context代表spring容器)
    		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");//只写这句也可以调用YellowMouseWolf类中的无参构造方法
             //获取spring容器中创建的对象(通过id值获取)
    		Ji ji=(Ji)context.getBean("smallJi");
    		ji.behavior();
    		//关闭context容器,并且销毁容器中所有的对象
    		((ClassPathXmlApplicationContext) context).close();
    		
    	}
    
    }
    

    结果:




    展开全文
  • Redis+Spring实例

    千次下载 热门讨论 2016-01-14 09:56:44
    Redis+Spring实例,使用环境:eclipse+maven+spring+junit。实例详解,请访问博主博客:http://blog.csdn.net/u013142781
  • spring 线程池实例

    热门讨论 2011-10-14 19:36:41
    线程池例子线程池例子线程池例子线程池例子
  • 公司项目在发到生产后启了2个实例,导致调度同时执行,起先使用了事务隔离和数据库控制执行版本,不过不是很好,不是最佳的解决方案,查了资料Quartz本身支持多实例,稍加配置即可。 此篇文章在Spring boot下使用...

    公司项目在发到生产后启了2个实例,导致调度同时执行,起先使用了事务隔离和数据库控制执行版本,不过不是很好,不是最佳的解决方案,查了资料Quartz本身支持多实例,稍加配置即可。
    此篇文章在Spring boot下使用Quartz 基础上进行修改,建议阅读完之后再看
    1. 下载quartz
    官网
    我用的是2.2.3

    **2. 创建表 **
    下载下来tar包后解压后打开
    quartz-2.2.3\docs\dbTables
    找到你需要的数据库sql文件执行
    例如:我用的是PG,执行的是tables_postgres.sql文件里的sql

    注意:2.3.0版本sql文件在quartz-2.3.0-SNAPSHOT\src\org\quartz\impl\jdbcjobstore

    3. 新增配置文件

    import java.util.Properties;
    import javax.sql.DataSource;
    import org.quartz.Scheduler;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.AutoConfigureAfter;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    
    @Configuration
    @AutoConfigureAfter(DruidAutoConfiguration.class)//在该类之后执行,为了使用dataSource,(DruidAutoConfiguration是连接数据库配置文件,参考文末)
    public class QuartzConfig {
    	@Autowired
    	private DataSource dataSource;
    	/**
    	 * 设置属性
    	 */
    	private Properties quartzProperties() {
    		Properties prop = new Properties();
    		//拉取trigger加锁
    		prop.put("org.quartz.jobStore.acquireTriggersWithinLock", "true");
    		prop.put("org.quartz.scheduler.instanceName", "quartzScheduler");
    		prop.put("org.quartz.scheduler.instanceId", "AUTO");
    		prop.put("org.quartz.scheduler.skipUpdateCheck", "true");
    		prop.put("org.quartz.scheduler.jmx.export", "true");
    		
    		// Configure JobStore
    		// #JobDataMaps是否都为String类型
    		// prop.put("org.quartz.jobStore.useProperties", "true");//不要用,报错
    		prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
    		// PG专用
    		prop.put("org.quartz.jobStore.driverDelegateClass",
    				"org.quartz.impl.jdbcjobstore.PostgreSQLDelegate");
    		// job注入datasource
    		// prop.put("org.quartz.jobStore.dataSource","druid");//#使用JNDI数据源的时候,数据源的名字
    		prop.put("org.quartz.jobStore.tablePrefix", "QRTZ_");
    		
    		// 开启集群
    		// #ture则此实例需要参加到集群中
    		prop.put("org.quartz.jobStore.isClustered", "true");
    		// #调度实例失效的检查时间间隔
    		prop.put("org.quartz.jobStore.clusterCheckinInterval", "20000");
    		// prop.put("org.quartz.jobStore.dataSource", "myDS");
    		// 这是 JobStore 能处理的错过触发的 Trigger 的最大数量
    		prop.put("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");
    		// #容许的最大作业延长时间
    		prop.put("org.quartz.jobStore.misfireThreshold", "60000");
    		//值为 true 时告知 Quartz(当使用 JobStoreTX 或 CMT) 
    		//调用 JDBC 连接的 setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE) 方法
    		//这有助于阻止某些数据库在高负载和长时间事物时锁的超时。
    		prop.put("org.quartz.jobStore.txIsolationLevelSerializable", "true");
    		prop.put("org.quartz.jobStore.selectWithLockSQL",
    				"SELECT * FROM {0}LOCKS WHERE LOCK_NAME = ? FOR UPDATE");
    		
    		// Configure ThreadPool
    		prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
    		prop.put("org.quartz.threadPool.threadCount", "50");
    		prop.put("org.quartz.threadPool.threadPriority", "5");
    		prop.put("org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread",
    				"true");
    		/*
    		 * prop.put("org.quartz.dataSource.myDS.driver", myDSDriver);
    		 * prop.put("org.quartz.dataSource.myDS.URL", myDSURL);
    		 * prop.put("org.quartz.dataSource.myDS.user", myDSUser);
    		 * prop.put("org.quartz.dataSource.myDS.password", myDSPassword);
    		 * System.out.println("myDSMaxConnections:" + myDSMaxConnections);
    		 * prop.put("org.quartz.dataSource.myDS.maxConnections",
    		 * myDSMaxConnections);
    		 */
    		prop.put("org.quartz.plugin.triggHistory.class",
    				"org.quartz.plugins.history.LoggingJobHistoryPlugin");
    		prop.put("org.quartz.plugin.shutdownhook.class",
    				"org.quartz.plugins.management.ShutdownHookPlugin");
    		prop.put("org.quartz.plugin.shutdownhook.cleanShutdown", "true");
    		return prop;
    	}
    
    	@Bean
    	public SchedulerFactoryBean schedulerFactoryBean() {//得到schedulerFactoryBean,并注入多实例参数
    		SchedulerFactoryBean factory = new SchedulerFactoryBean();
    		// this allows to update triggers in DB when updating settings in config
    		// file:
    		// 用于quartz集群,QuartzScheduler
    		// 启动时更新己存在的Job,这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了
    		factory.setOverwriteExistingJobs(true);
    		// 用于quartz集群,加载quartz数据源
    		factory.setDataSource(dataSource);
    		// QuartzScheduler 延时启动,应用启动完10秒后 QuartzScheduler 再启动
    		factory.setStartupDelay(10);
    		// 用于quartz集群,加载quartz数据源配置
    		factory.setQuartzProperties(quartzProperties());
    		factory.setAutoStartup(true);
    		// applicationContextSchedulerContextKey:
    		// 是org.springframework.scheduling.quartz.SchedulerFactoryBean这个类中把spring上下
    		// 文以key/value的方式存放在了quartz的上下文中了,可以用applicationContextSchedulerContextKey所定义的key得到对应的spring上下文
    		// factory.setApplicationContextSchedulerContextKey("applicationContext");
    		// factory.setConfigLocation(new
    		// FileSystemResource(this.getClass().getResource("/quartz.properties").getPath()));
    		return factory;
    	}
    
        //得到scheduler
    	@Bean
    	public Scheduler scheduler(SchedulerFactoryBean schedulerFactoryBean) {
    		return schedulerFactoryBean.getScheduler();
    	}
    }
    
    

    4. 修改ServiceImpl实现类的scheduler注入方式
    一些调度器操作

    @Service
    @Slf4j
    public class SchedulerServiceImpl implements SchedulerService {
    
    	@Autowired
    	private  Scheduler scheduler;
    	
    	内容省略,跟上一遍文章一样。
    }
    

    文末. (仅供参考)
    连接数据库的配置文件
    DruidAutoConfiguration.java

    import java.sql.SQLException;
    import javax.sql.DataSource;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.AutoConfigureBefore;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import com.alibaba.druid.pool.DruidDataSource;
    
    @Configuration
    @EnableConfigurationProperties(DruidProperties.class)
    @ConditionalOnClass(DruidDataSource.class)
    @ConditionalOnProperty(prefix = "druid", name = "url")
    @AutoConfigureBefore(DataSourceAutoConfiguration.class)
    public class DruidAutoConfiguration {
    
        @Autowired
        private DruidProperties properties;
    
        @Bean
        public DataSource dataSource() {
        	
        	System.out.println(DataConverterUtil.object2Json(properties));
        	System.out.println(DataConverterUtil.object2Json(properties));
        	System.out.println(DataConverterUtil.object2Json(properties));
        	System.out.println(DataConverterUtil.object2Json(properties));
        	
            DruidDataSource dataSource = new DruidDataSource();
            dataSource.setUrl(properties.getUrl());
            dataSource.setUsername(properties.getUsername());
            dataSource.setPassword(properties.getPassword());
            if (properties.getInitialSize() > 0) {
                dataSource.setInitialSize(properties.getInitialSize());
            }
            if (properties.getMinIdle() > 0) {
                dataSource.setMinIdle(properties.getMinIdle());
            }
            if (properties.getMaxActive() > 0) {
                dataSource.setMaxActive(properties.getMaxActive());
            }
            dataSource.setTestOnBorrow(properties.isTestOnBorrow());
            try {
                dataSource.init();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
            return dataSource;
        }
    }
    

    DruidProperties .java

    import org.springframework.boot.context.properties.ConfigurationProperties;
    
    @ConfigurationProperties(prefix = "druid")
    public class DruidProperties {
        private String url;
        private String username;
        private String password;
        private String driverClass;
    
        private int     maxActive;
        private int     minIdle;
        private int     initialSize;
        private boolean testOnBorrow;
    
        public String getUrl() {
            return url;
        }
    
        public void setUrl(String url) {
            this.url = url;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public String getDriverClass() {
            return driverClass;
        }
    
        public void setDriverClass(String driverClass) {
            this.driverClass = driverClass;
        }
    
        public int getMaxActive() {
            return maxActive;
        }
    
        public void setMaxActive(int maxActive) {
            this.maxActive = maxActive;
        }
    
        public int getMinIdle() {
            return minIdle;
        }
    
        public void setMinIdle(int minIdle) {
            this.minIdle = minIdle;
        }
    
        public int getInitialSize() {
            return initialSize;
        }
    
        public void setInitialSize(int initialSize) {
            this.initialSize = initialSize;
        }
    
        public boolean isTestOnBorrow() {
            return testOnBorrow;
        }
    
        public void setTestOnBorrow(boolean testOnBorrow) {
            this.testOnBorrow = testOnBorrow;
        }
    }
    
    

    application.properties

    ## 需要修改数据库连接信息
    druid.url=jdbc:postgresql://11.11.11.11:7443/test
    druid.driver-class=org.postgresql.Driver
    druid.username=testdata
    druid.password=yang1234
    druid.initial-size=1
    druid.min-idle=1
    druid.max-active=20
    druid.test-on-borrow=true
    

    喜欢请点赞,不懂请留言^^

    展开全文
  • springcloud启动实例

    千次阅读 2019-07-10 12:20:24
    springcloud微服务,部署一般需要台服务器配合,开发测试过程中,也需要启动实例来进行测试与验证。 2. 问题解决 在idea下,只需要配置下就能启动实例,本案例采用在idea下部署2个不同端口的Eureka实例...
  • spring cloud实例Dome详细搭建(一)

    万次阅读 多人点赞 2019-05-17 14:33:19
    详解搭建spring cloud的实例Demo,跟着一步一步走,肯定可以的 准备工作: 1.首先创建一个父项目,一个普通的java项目 2.创建好父项目后,在pom.xml中配置springcloud和springboot的统一版本 <properties&...
  • spring通过注解的方式使用例模式

    千次阅读 2020-10-20 21:00:12
    说明:spring容器实例化对象时默认使用单例模式,初学时也知道实现例模式可以在容器文件中给bean添加prototype,再通过applicationContext获取不同的实例。 那么,如何只使用注解而不去配置文件里的内容来获得不同...
  • socket结合spring实例

    热门讨论 2012-01-09 10:06:12
    socket结合spring的java工程,工程里缺少spring.jar包
  • spring security acl 实例

    2017-12-01 07:33:07
    spring security acl 代码实例 spring security acl 代码实例spring security acl 代码实例spring security acl 代码实例spring security acl 代码实例spring security acl 代码实例
  • 基于用户,角色,权限的spring security完整项目,包括登陆,免登陆,session配置,角色,权限验证等功能
  • Spring实例

    2017-09-18 23:15:25
    Spring实例Spring实例Spring实例Spring实例Spring实例Spring实例Spring实例Spring实例Spring实例Spring实例Spring实例
  • Spring Boot 2.X 实战教程

    千人学习 2019-07-27 21:40:25
    本课程内容包括Spring简介、Spring Boot简介、安装JDK、安装Maven、第一个Spring Boot...Spring Data JPA增删改查实例、安装Redis和可视化客户端、Redis缓存配置、Redis缓存实例、Redis消息、测试Spring Boot应用程序...
  • Spring中Bean的单例、

    万次阅读 2019-07-09 19:10:16
    2 @Component注解默认实例化的对象是单例,如果想声明成例对象可以使用@Scope(“prototype”) @Component @Scope(“prototype”) 3 @Repository默认单例 4 @Service默认单例 5 @Controller默认例 问题二:...
  • spring入门实例详解

    万次阅读 多人点赞 2015-09-06 17:14:01
    spring框架在我们的开发中用到的很,前面几篇博客也理解了一下spring的基本概念,现在准备写一个spring框架的入门实例,以一个登陆认证签到模块为例子; 实例说明: 登陆签到模块其实很简单,首先用户输入网址,...
  • 创建Bean的入口:org.springframework.beans....实例化 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance protected BeanWrapper createBeanInstance(String beanNa.
  • spring webflow 实例

    2017-12-01 07:37:08
    spring webflow 实例spring webflow 实例spring webflow 实例spring webflow 实例spring webflow 实例spring webflow 实例
  • spring中的单例和例中的坑

    万次阅读 2018-07-25 17:40:22
    此处仅是问题的简单描述,并没有按照规范整理,请大家谅解,这是我在遇到这样问题时,随手按照自己的想法记录下了自己的心得,看着有些乱,不过全是干货,希望谅解;   //在springboot 整合...如果我们有个...
  • Spring整合Redis完整实例代码,下载经简单的修改配置文件,即可运行,代码中有详细的注释,关于代码的详情可参见博文:http://blog.csdn.net/l1028386804/article/details/52108758
  • Spring官网阅读(一)容器及实例

    千次阅读 多人点赞 2020-03-10 23:22:08
    不管是之前关于动态代理的文章,还是读Spring的官网,都是为了之后对Spring的源码做更全面细致的学习,所以在这个过程中,不会涉及过多底层的代码,更是通过例子证明我们在官网得出的结论,希望自己可以坚持下来,...
  • Spring Security3.1实例

    热门讨论 2012-05-13 13:04:44
    spring security3.1 在数据库实现 用户 角色 资源 权限控制,在eclipse+tomcat下测试通过
  • cxf spring maven 实例

    热门讨论 2013-01-10 14:57:05
    cxf spring maven 实例 webservice
  • Spring三种实例化方式

    千次阅读 2018-08-21 23:15:44
    同样,在Spring中,要想使用容器中的Bean,也需要实例化Bean。实例化Bean有三种方式,分别为构造器实例化、静态工厂方式实例化和实例工厂方式实例化(其中最常用的是构造器实例化) 1.构造器实例化 public class ...
  • Spring AOP 实例

    千次阅读 2018-05-15 14:52:26
    在实际开发作业中,我们经常需要对实现功能做性能监视。...AOP的实现由很,这里我们采用Spring AOP,它不需要专门的编译方式和特殊的类装载器,它在运行期通过动态代理方式来实现想目标类织入上文...
  • 这个实例帮助开发者更容易地创建基于Spring Boot的应用程序,使得Spring开发者能够最快速地掌握Spring Boot的基本用法。这是一个简单的实例,完全可以跑起来的。
  • client可以使用同一个服务实例的方法 来解决单点故障问题 只要更改server.port端口重新启动一下 就可以创建另一个实例 Application AMIs Availability Zones Status ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 454,421
精华内容 181,768
关键字:

spring多实例

spring 订阅