j2ee开发之Spring2.5框架学习笔记

Spring 2.5框架学习笔记

1.是一个开源的控制反转IOC和面向切面AOP的容器框架

2.IOC控制反转

public class PersonServiceBean {

private PersonDao personDao = new PersonDao();

publiv void save(Person person){

personDao.save(person);

}

}

控制反转：应用本身不负责依赖对象personDao的创建以及维护，依赖对象的创建以及维护是由外部容器负责的，这样控制权就由应用转移到了外部的容器，控制权的转移就是反转。

3.依赖注入(Dependency injection) ：

依赖注入：在运行期间由外部容器动态地将依赖对象注入到组件中

改写的PersonServiceBean

public class PersonServiceBean {

private PersonDao persondao;

public PersonServiceBean(PersonDao persondao){

this.persondao=persondao;

}

public void save(Person person){

persondao.save(person);

}

}

利用了构造器，让容器把创建好的对象注入到PersonServiceBean,在构造器中将Dao层的对象注入到了业务层。

4.Spring不需要手工控制事务

5.重量级还是轻量级变量？

使用的服务越多，容器为普通的java对象做得工作就越多，影响到应用的发布时间和运行性能。这时就是重量级的。对于spring容器，如果仅仅使用核心的服务，就是轻量级的。

6.环境搭建：

7.配置文件beans.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"

xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

<bean id="personService" class="test.PersonServiceBean"></bean>

</beans>

8.spring的第一例子

//抽取的接口

package impls;

public interface PersonService {

public abstract void save();

}

//接口的实现方法

package service;

import impls.PersonService;

public class PersonServiceBean implements PersonService {

/* (non-Javadoc)

* @see service.impl.PersonService#save()

*/

public void save(){

System.out.println("save function");

}

}

package test;

import impls.PersonService;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {

public static void setUpBeforeClass(){

}

public static void instanceSpring(){

//根据配置文件，创建一个spring容器的实例

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

//从容器中，根据id，取得业务层对象

PersonService ps =(PersonService)ctx.getBean("personService");

//调用业务层对象的方法

ps.save();

}

}

9.spring实例化bean的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，由容器维护,即将bean放在了容器中 -->

<!-- 类的构造器实例化 -->

<bean id="personService" class="service.PersonServiceBean"></bean>

<!-- 静态工厂实例化 -->

<bean id="personService2" class="service.PersonServiceBeanFactory" factory-method="createPersonService"></bean>

<!-- 动态工厂方法实例化 -->

<bean id="personServiceFactory" class="service.PersonServiceBeanFactory" >  </bean>

<bean id="personService3" factory-bean="personServiceFactory" factory-method="createPersonService2"> </bean>

</beans>

package service;

public class PersonServiceBeanFactory {

//静态的工厂方法,createPersonService

//返回一个PersonServiceBean对象

public static PersonServiceBean createPersonService(){

return new PersonServiceBean();

}

//实例工厂方法

public PersonServiceBean createPersonService2(){

return new PersonServiceBean();

}

}

10.两次调用方法getBean()，是不是引用的是同一个对象？

是同一个对象，即使一个单实例对象。

默认：singleton作用域，单例模式，bean的实例化在创建容器时

在prototype作用域下，每次调用会返回一个新的对象bean的实例化在容器调取bean

<bean id="personService" class="service.PersonServiceBean" scope="prototype"></bean>

scope="prototype"    scope="singleton"

setter方法注入：

11.类对象类型的注入

<!-- 类的构造器实例化 -->

<bean id="personDao" class="dao.PersonDaoBean"></bean>

<bean id="personService" class="service.PersonServiceBean" >

<property name="personDao" ref="personDao"></property>

</bean>

理解：ref的值是第一个bean的id,property的name为定义的属性(你要注入的一个类的对象)，在PersonServiceBean中一定定义了personDao对象的属性

dao.PersonDaoBean是这样定义的：

package dao;

import impls.PersonDao;

public class PersonDaoBean implements PersonDao {

public void add() {

System.out.println("执行PersonDaoBean中的add方法");

}

}

PersonSeviceBean是这样定义的：

package service;

import impls.PersonDao;

import impls.PersonService;

public class PersonServiceBean implements PersonService {

//属性为PersonDao类对象

private PersonDao personDao;

public PersonDao getPersonDao() {

return personDao;

}

public void setPersonDao(PersonDao personDao) {

this.personDao = personDao;

}

//重写接口中的save方法

public void save(){

personDao.add();

}

}

11.采用内部bean的方式注入bean

<!-- 采用内部bean的方法 -->

<bean id="personService" class="service.PersonServiceBean">

<property name="personDao">

<bean class="dao.PersonDaoBean"></bean>

</property>

</bean>

12.基本类型数据的bean注入，由property标签控制

<bean id="personDao" class="dao.PersonDaoBean"></bean>

<bean id="personService" class="service.PersonServiceBean">

<property name="personDao" ref="personDao"></property>

<property name="username" value="admin"></property>

</bean>

业务层这样写：

package service;

import impls.PersonDao;

import impls.PersonService;

public class PersonServiceBean implements PersonService {

//属性为接口PersonDao

private PersonDao personDao;

//定义的基本数据类型，一定要提供get/set方法

private String username;

public String getUsername() {

return username;

}

public void setUsername(String username) {

this.username = username;

}

public PersonDao getPersonDao() {

return personDao;

}

public void setPersonDao(PersonDao personDao) {

this.personDao = personDao;

}

//重写接口中的save方法

public void save(){

personDao.add();

System.out.println("name:"+username);

}

}

13.集合类型的注入，也是由property控制：

Set类型：

<bean id="personDao" class="dao.PersonDaoBean"></bean>

<bean id="personService" class="service.PersonServiceBean">

<property name="personDao" ref="personDao"></property>

<property name="username" value="admin"></property>

<property name="id" value="123"></property>

<property name="sets">

<set>

<value>admin1</value>

<value>admin2</value>

<value>admin3</value>

</set>

</property>

</bean>

List类型：

<property name="lists">

<list>

<value>admin4</value>

<value>admin5</value>

<value>admin6</value>

</list>

</property>

map类型：

<property name="maps">

<map>

<entry key="key-1" value="value-1"></entry>

<entry key="key-2" value="value-2"></entry>

<entry key="key-3" value="value-3"></entry>

</map>

</property>

业务层：

package service;

import impls.PersonDao;

import impls.PersonService;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

public class PersonServiceBean implements PersonService {

//定义类对象的属性personDao

private PersonDao personDao;

//定义基本数据类型username id

private String username;

private int id;

//定义集合属性sets

private Set<String> sets = new HashSet<String>();

//定义集合属性lists

private List<String> lists = new ArrayList<String>();

//定义属性集合maps

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

public Map<String, String> getMaps() {

return maps;

}

public void setMaps(Map<String, String> maps) {

this.maps = maps;

}

public List<String> getLists() {

return lists;

}

public void setLists(List<String> lists) {

this.lists = lists;

}

public Set<String> getSets() {

return sets;

}

public void setSets(Set<String> sets) {

this.sets = sets;

}

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public String getUsername() {

return username;

}

public void setUsername(String username) {

this.username = username;

}

public PersonDao getPersonDao() {

return personDao;

}

public void setPersonDao(PersonDao personDao) {

this.personDao = personDao;

}

//重写接口中的save方法

public void save(){

personDao.add();

System.out.println("name:"+username);

System.out.println("id:"+id);

}

}

客户端调用：

举例：对于map集合

package test;

import impls.PersonService;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {

public static void setUpBeforeClass(){

}

public static void instanceSpring(){

//根据配置文件，创建一个spring容器的实例

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

//从容器中，根据id，取得对象

PersonService ps =(PersonService)ctx.getBean("personService");

for(String key :ps.getMaps().keySet()){

System.out.println("value:"+ps.getMaps().get(key));

}

}

}

接口申明：

注意：在PersonServiceBean 中实现的是PersonService 接口，所以 ，接口中的定义有取得集合元素的方法：

package impls;

import java.util.List;

import java.util.Map;

import java.util.Set;

public interface PersonService {

public abstract void save();

public Set<String> getSets();

public List<String> getLists();

public Map<String, String> getMaps();

}

对于集合类型都为XXXGet方法，取得集合中的元素值。

构造器注入

14.配置文件：

<bean id="personDao" class="dao.PersonDaoBean"></bean>

<bean id="personService" class="service.PersonServiceBean">

<!-- 利用构造器参数注入 -->

<!-- 为第一个参数注入值 ，ref为要注入的对象 type为接口名-->

<constructor-arg index="0" type="impls.PersonDao" ref="personDao"></constructor-arg>

<!-- 为第二个参数注入值，基本数据类型不用指定type,value为要注入的值 -->

<constructor-arg index="1"  value="xjq"></constructor-arg>

我的理解：构造器注入是，利用constructor属性，类对象用ref,基本数据类型用value指定

业务层：

//演示构造器注入两个属性personDao和username，一定要提供构造器方法

public PersonServiceBean(PersonDao personDao, String username) {

this.personDao = personDao;

this.username = username;

}

//定义类对象的属性personDao

private PersonDao personDao;

//定义基本数据类型username

private String username;

//重写接口中的save方法

   public void save(){

System.out.println("name:"+username);

personDao.add();

}

}

客户端的调用：

package test;

import impls.PersonService;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {

public static void instanceSpring(){

//根据配置文件，创建一个spring容器的实例

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

//从容器中，根据id，取得对象

PersonService ps =(PersonService)ctx.getBean("personService");

ps.save();

}

}

最后的输出：

name:xjq

执行PersonDaoBean中的add方法

15.有了注解的配置文件：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:context="http://www.springframework.org/schema/context"       

       xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

<context:annotation-config/>        <beanid="personDaoxxxx"class="cn.itcast.dao.impl.PersonDaoBean"></bean>

<beanid="personService"class="cn.itcast.service.impl.PersonServiceBean">

</bean>

</beans>

16.利用注解字段的方式，进行bean的注入

配置文件：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

<context:annotation-config/>

<!--这些bean都是用来定义实体类的-->

<bean id="personDao" class="dao.PersonDaoBean"></bean>

<bean id="personService" class="service.PersonServiceBean"></bean>

</beans>

业务层：

@Resource修饰属性

package service;

import impls.PersonDao;

import impls.PersonService;

import javax.annotation.Resource;

public class PersonServiceBean implements PersonService {

//定义类对象的属性personDao

@Resource private PersonDao personDao;

//定义基本数据类型username id

private String username;

//重写接口中的save方法

public void save(){

personDao.add();

}

}

17.利用注解setter的方式，进行bean的注入

@Resource修饰set方法

package service;

import impls.PersonDao;

import impls.PersonService;

import javax.annotation.Resource;

public class PersonServiceBean implements PersonService {

//定义类对象的属性personDao

private PersonDao personDao;

//为字段的set方法加@Resource注解，配置文件不变

@Resource

public void setPersonDao(PersonDao personDao) {

this.personDao = personDao;

}

//定义基本数据类型username id

private String username;

//重写接口中的save方法

public void save(){

personDao.add();

}

}

18.利用@Autowired进行依赖注入

是一种按照类型进行装配

业务层：

@Autowired利用该注释修饰属性

package service;

import impls.PersonDao;

import impls.PersonService;

import org.springframework.beans.factory.annotation.Autowired;

public class PersonServiceBean implements PersonService {

//定义类对象的属性personDao

@Autowired private PersonDao personDao;

public void setPersonDao(PersonDao personDao) {

this.personDao = personDao;

}

//重写接口中的save方法

public void save(){

personDao.add();

}

}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

<context:annotation-config/>

<bean id="personDao" class="dao.PersonDaoBean"></bean>

<bean id="personService" class="service.PersonServiceBean"></bean>

</beans>

19.自动装配，但是不推荐，会有很多意外的情况

20.AOP技术

自己利用jdk编写：

目标类接口：

package aop;

public interface PersonService {

public void save(String name);

public void update(String name,Integer personId);

public String getPersonName(Integer personId);

}

业务层：

package aop_service;

import aop.PersonService;

//业务层：PersonServiceBean

/*

* 拦截用户对方法的请求

* 判断用户是否有权限(user是否为null)执行业务方法

* 有则执行，没有的话就不执行

*

* */

public class PersonServiceBean implements PersonService {

//定义一个用户user

private String user = null;

public String getUser() {

return user;

}

//构造器

public PersonServiceBean(String user) {

this.user = user;

}

public PersonServiceBean() {

super();

// TODO Auto-generated constructor stub

}

public void save(String name) {

// TODO Auto-generated method stub

System.out.println("我是save方法");

}

public void update(String name, Integer personId) {

// TODO Auto-generated method stub

System.out.println("我是update方法");

}

public String getPersonName(Integer personId) {

// TODO Auto-generated method stub

return "admin";

}

}

代理工厂：

package aop_service;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

public class JDKProxyFactory implements java.lang.reflect.InvocationHandler {

//定义一个目标对象

private Object targetObject;

//创建代理实例

public Object createProxyInstance(Object targetObject){

this.targetObject=targetObject;

return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),

this.targetObject.getClass().getInterfaces(),this);

}

//返回一个代理对象

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

// TODO Auto-generated method stub

PersonServiceBean bean = (PersonServiceBean) this.targetObject;

Object result = null;

if(bean.getUser()!=null){

result = method.invoke(targetObject, args);

}

return result;

}

}

测试：

package test;

import aop.PersonService;

import aop_service.JDKProxyFactory;

import aop_service.PersonServiceBean;

public class aopTest {

public static void main(String[] args) {

// TODO Auto-generated method stub

//创建代理工厂

JDKProxyFactory ff = new JDKProxyFactory();

//返回代理对象

PersonService ps = (PersonService)ff.createProxyInstance(new PersonServiceBean("xxx"));

ps.save("888");

}

}

21.利用spring进行aop开发

前置通知 后置通知  最终通知 环绕通知 异常通知

一定要引入的jar包：

配置文件：

<?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"

xmlns:aop="http://www.springframework.org/schema/aop"

xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd

           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<aop:aspectj-autoproxy/>

<!-- 将切面类交给spring容器去管理 -->

<bean id="myInterceptor" class="aop.MyInterceptor"/>

<!-- 将业务bean也交给spring管理 -->

<bean id="personService" class="aop_service.PersonServiceBean"></bean>

</beans>

利用注解的方法进行：

切面类和切入点的定义：

package aop;

import org.aspectj.lang.annotation.AfterReturning;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.aspectj.lang.annotation.Pointcut;

//申明该类为一个切面 ，该切面应该交由spring容器进行管理,基于xml配置去管理

@Aspect

public class MyInterceptor {

//申明一个切入点

@SuppressWarnings("unused")

@Pointcut("execution(* aop_service.PersonServiceBean.*(..))")

private void anyMethod(){}

//在执行业务方法前，前置通知

@Before("anyMethod()")

public void doAccessCheck(){

System.out.println("前置通知");

}

//在执行业务方法后，后置通知

@AfterReturning("anyMethod()")

public void doAfterReturning(){

System.out.println("后置通知");

}

//最终的通知

@After("anyMethod()")

public void doAfter(){

System.out.println("最终通知");

}

}

业务层：

package aop_service;

import aop.PersonService;

//业务层：PersonServiceBean

/*

* 拦截用户对方法的请求

* 判断用户是否有权限(user是否为null)执行业务方法

* 有则执行，没有的话就不执行

*

* */

public class PersonServiceBean implements PersonService {

public void save(String name) {

// TODO Auto-generated method stub

System.out.println("我是save方法");

}

public void update(String name, Integer personId) {

// TODO Auto-generated method stub

System.out.println("我是update方法");

}

public String getPersonName(Integer personId) {

// TODO Auto-generated method stub

System.out.println("我是getPersonName方法");

return "admin";

}

}

测试类：

package test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import aop.PersonService;

public class SpringAopTest {

public static void main(String[] args) {

// TODO Auto-generated method stub

//创建spring容器

ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");

//容器先取得业务层的bean

PersonService ps = (PersonService)cxt.getBean("personService");

//调用业务层对象的save方法

ps.save("xxx");

}

}

输出：

22.环绕通知

//环绕通知

@Around("anyMethod()")

public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{

System.out.println("进入方法");

Object result  = pjp.proceed();

System.out.println("退出方法");

return result;

}

环绕通知经常可以用于权限控制

23.利用xml进行配置aop

配置文件：

<?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"

xmlns:aop="http://www.springframework.org/schema/aop"

xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd

           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<aop:aspectj-autoproxy />

<!-- 将业务bean也交给spring管理 -->

<bean id="personService" class="aop_service.PersonServiceBean"></bean>

     <!-- 将拦截类对象交给  spring管理-->

<bean id="aspetbean" class="aop.MyInterceptor"></bean>

<aop:config>

<aop:aspect id="asp" ref="aspetbean">

<aop:pointcut id="mycut"

expression="execution(* aop_service.PersonServiceBean.*(..))"/>

<aop:before pointcut-ref="mycut" method="doAccessCheck" />

</aop:aspect>

</aop:config>

</beans>

业务层：拦截bean，是一个普通的类对象

package aop;

import org.aspectj.lang.ProceedingJoinPoint;

//申明该类为一个切面 ，该切面应该交由spring容器进行管理,基于xml配置去管理

public class MyInterceptor {

//在执行业务方法前，前置通知

public void doAccessCheck(){

System.out.println("前置通知");

}

//在执行业务方法后，后置通知

public void doAfterReturning(){

System.out.println("后置通知");

}

//最终的通知

public void doAfter(){

System.out.println("最终通知");

}

//环绕通知

public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{

System.out.println("进入方法");

Object result  = pjp.proceed();

System.out.println("退出方法");

return result;

}

}

普通的业务类对象：

package aop_service;

import aop.PersonService;

public class PersonServiceBean implements PersonService {

public void save(String name) {

// TODO Auto-generated method stub

System.out.println("我是save方法");

}

public void update(String name, Integer personId) {

// TODO Auto-generated method stub

System.out.println("我是update方法");

}

public String getPersonName(Integer personId) {

// TODO Auto-generated method stub

System.out.println("我是getPersonName方法");

return "admin";

}

}

测试文件：

package test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import aop.PersonService;

public class SpringAopTest {

public static void main(String[] args) {

// TODO Auto-generated method stub

//创建spring容器

ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");

//容器先取得业务层的bean

PersonService ps = (PersonService)cxt.getBean("personService");

//调用业务层对象的save方法

ps.save("xxx");

}

}

24.expression="execution(* aop_service.PersonServiceBean.*(..))的理解

返回值类型为所有类型 用 .  表示 ，可以拦截aop_service包下的PersonServiceBean类的所有的方法，参数类型为所有的类型,用 . . 表示。

!可以取反     !void  拦截不是void类型的

25.aop适合权限系统的使用

26.spring+jdbc组合开发

beans.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"

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd

           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd

           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

<!-- 启用占位符，配置数据库连接 -->

<context:property-placeholder location="classpath:jdbc.properties" />

<!-- 控制数据连接 -->

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close">

<property name="driverClassName" value="${driverClassName}" />

<property name="url" value="${url}" />

<property name="username" value="${username}" />

<property name="password" value="${password}" />

<!-- 连接池启动时的初始值 -->

<property name="initialSize" value="${initialSize}" />

<!-- 连接池的最大值 -->

<property name="maxActive" value="${maxActive}" />

<!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->

<property name="maxIdle" value="${maxIdle}" />

<!-- 最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->

<property name="minIdle" value="${minIdle}" />

</bean>

<!-- 事务管理器 -->

<bean id="txManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<property name="dataSource" ref="dataSource" />

</bean>

<!-- 对注解进行解析没，需要指定一个事务管理器 -->

<tx:annotation-driven transaction-manager="txManager" />

<!-- 基于xml将dataSource属性注入 -->

<bean id="personService" class="JDBCSpring.PersonServiceBean">

<property name="dataSource" ref="dataSource" />

</bean>

</beans>

数据库配置的属性文件jdbc.properties：

driverClassName=org.gjt.mm.mysql.Driver

url=jdbc\:mysql\://localhost\:3306/demo?useUnicode\=true&characterEncoding\=UTF-8

username=root

password=

initialSize=1

maxActive=500

maxIdle=2

minIdle=1

业务类：

package JDBCSpring;

import java.util.List;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;

import bean.Person;

public class PersonServiceBean implements JDBCSpring.PersonService {

private JdbcTemplate jdbcTemplate;

public void setDataSource(DataSource dataSource) {

this.jdbcTemplate = new JdbcTemplate(dataSource);

}

public void delete(Integer personid) {

jdbcTemplate.update("delete from person where id=?", new Object[]{personid},

new int[]{java.sql.Types.INTEGER});

}

public Person getPerson(Integer personid) {

/*return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid},

new int[]{java.sql.Types.INTEGER}, new PersonRowMapper());*/

return null;

}

public List<Person> getPersons() {

//return (List<Person>)jdbcTemplate.query("select * from person", new PersonRowMapper());

return null;

}

public void save(Person person) {

jdbcTemplate.update("insert into person(name) values(?)", new Object[]{person.getName()},

new int[]{java.sql.Types.VARCHAR});

}

public void update(Person person) {

jdbcTemplate.update("update person set name=? where id=?", new Object[]{person.getName(), person.getId()},

new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});

}

}

实例类：

package bean;

public class Person {

public Person(String name) {

this.name = name;

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

private Integer id;

private String name;

}

测试类：

package JDBCSpring;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import bean.Person;

public class jdbcTest {

public static void main(String[] args) {

ApplicationContext act = new ClassPathXmlApplicationContext("beans.xml");

PersonService ps = (PersonService) act.getBean("personService");

ps.save(new Person("haha"));

System.out.println("ok!");

}

}

时间： 2024-10-18 10:29:37

j2ee开发之Spring2.5框架学习笔记的相关文章

JavaSE中线程与并行API框架学习笔记1——线程是什么？

前言:虽然工作了三年,但是几乎没有使用到多线程之类的内容.这其实是工作与学习的矛盾.我们在公司上班,很多时候都只是在处理业务代码,很少接触底层技术. 可是你不可能一辈子都写业务代码,而且跳槽之后新单位很可能有更高的技术要求.除了干巴巴地翻书,我们可以通过两个方式来解决这个问题:一是做业余项目,例如在github上传自己的demo,可以实际使用:二是把自己的学习心得写成博客,跟同行们互相交流. 3.1 线程的初窥门径 我们在之前的文章里提到的程序其实都是单线程程序,也就说启动的程序从main()程

windows下scrapy框架学习笔记—&#39;scrapy&#39; 不是内部或外部命令

最近几天在深入的学习scrapy框架,但是装完各种需要的基础包之后却发现scrapy命令在别的路径下都用不了,我一开始是把python安装在F:\Python路径下的,安装了scrapy后它默认都会安装在这个路径下,scrapy在路径F:\Python\Scripts路径下,我的scrapy命令只能在此路径下用,因此创建什么工程也都只能在此文件下. 想了一下它的工作原理:它在F:\Python\Scripts路径下,就会在Scripts文件下存在一个scrapy批处理文件,那么在DOS下想要命令

JavaSE中线程与并行API框架学习笔记——线程为什么会不安全？

前言:休整一个多月之后,终于开始投简历了.这段时间休息了一阵子,又病了几天,真正用来复习准备的时间其实并不多.说实话,心里不是非常有底气. 这可能是学生时代遗留的思维惯性--总想着做好万全准备才去做事.当然,在学校里考试之前当然要把所有内容学一遍和复习一遍.但是,到了社会里做事,很多时候都是边做边学.应聘如此,工作如此,很多的挑战都是如此.没办法,硬着头皮上吧. 3.5 线程的分组管理 在实际的开发过程当中,可能会有多个线程同时存在,这对批量处理有了需求.这就有点像用迅雷下载电视剧,假设你在同时

JavaSE中Collection集合框架学习笔记(2)——拒绝重复内容的Set和支持队列操作的Queue

前言:俗话说“金三银四铜五”,不知道我要在这段时间找工作会不会很艰难.不管了,工作三年之后就当给自己放个暑假. 面试当中Collection(集合)是基础重点.我在网上看了几篇讲Collection的文章,大多都是以罗列记忆点的形式书写的,没有谈论实现细节和逻辑原理.作为个人笔记无可厚非,但是并不利于他人学习.希望能通过这种比较“费劲”的讲解,帮助我自己.也帮助读者们更好地学习Java.掌握Java. 无论你跟我一样需要应聘,还是说在校学生学习Java基础,都对入门和进一步启发学习有所帮助.(关

SuperSocket框架学习笔记4-SuperWebSocket---使用SubCommandBase

首先下载所需要的 DLL http://download.csdn.net/detail/wai2dance123/7389285 或者参见第2章  到SuperSocket官网下载 http://www.cnblogs.com/xmcrew/p/3747354.html 1,新建一个 .NET4.0 控制台应用程序 命名为 DiyServers 添加以下引用 将默认的Program.cs改名为  DiyServers.cs 并添加以下命名空间 2,写自己的DSession和DServer继承自

JavaSE中Collection集合框架学习笔记(3)——遍历对象的Iterator和收集对象后的排序

前言:暑期应该开始了,因为小区对面的小学这两天早上都没有像以往那样一到七八点钟就人声喧闹.车水马龙. 前两篇文章介绍了Collection框架的主要接口和常用类,例如List.Set.Queue,和ArrayList.HashSet.LinkedList等等.根据核心框架图,相信我们都已经对Collection这个JavaSE中最常用API之一有一个较为全面的认识. 这个学习过程,还可以推及到其他常用开源框架和公司项目的学习和熟悉上面.借助开发工具或说明文档,先是对项目整体有一个宏观的认识,再根

Java集合框架学习笔记之集合与Collection API

一.CollectionAPI 集合是一系列对象的聚集(Collection).集合在程序设计中是一种重要的数据接口.Java中提供了有关集合的类库称为CollectionAPI. 集合实际上是用一个对象代表一组对象,在集合中的每个对象称为一个元素.在集合中的各个元素的具体类型可以不同,但一般说来,它们都是由相同的类派生出来的(而这一点并不难做到,因为Java中的所有类都是Object的子类).在从集合中检索出各个元素是,常常要根据其具体类型不同而进行相应的强制类型转换. Collection

SuperSocket框架学习笔记3-构建Unity3D__WebSocket4Net客户端程序

确保上一节服务器程序运行没有问题,否则请仔细看上一节 新建一个Unity3D项目(我的Unity3D版本是4.2.0) 1,在Unity3D内新建一个文件夹命名 Plugin 将下载的 客户端: WebSocket4Net  客户端必备 http://websocket4net.codeplex.com/ WebSocket4Net.dll   这个DLL复制到 Unity3D里面刚才新建的 Plugin文件夹内(注意Unity不得使用中文) ----------- 查看Unity下面的状态面板

MEAN框架学习笔记

MEAN框架学习笔记 MEAN开发框架的资料非常少.基本的资料还是来自于learn.mean.io站点上的介绍. 于是抱着一种零基础学习的心态,在了解的过程中,通过翻译加上理解将MEAN框架一点点消化而且吸收,一步一步来.慢慢地记录我学习MEAN的点点滴滴. 1.MEAN是可以管理用户的 通过MEAN的mean-cli来管理用户.命令是: $ mean user <email> $ mean user <email> --addRole <role>; $ mean u