Spring必会(精美)

1 Spring介绍:

Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。

一句话概括：

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

1.1特点:

1.方便解耦，简化开发(通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，)

2 AOP面向切面编程支持

3 声明式实物支持

4方便程序测试

5 方便集成各种优秀框架

1.2组织架构

ORM- object relation mapping

OXM - Object xml mapping

JMS - Java 消息服务（ Java Message Service ， JMS ）

WebSocket protocol 是 HTML5 一种新的协议。它实现了浏览器与服务器全双工通信 (full-duplex) 。一开始的握手需要借助HTTP 请求完成。 Socket 是传输控制层协议， WebSocket 是应用层协议。

Portlet 是一种 Web 组件－就像 servlets －是专为将合成页面里的内容聚集在一起而设计的。通常请求一个portal 页面会引发多个 portlets 被调用。每个 portlet 都会生成标记段，并与别的 portlets 生成的标记段组合在一起嵌入到portal 页面的标记内

1.3spring核心模块

- spring-core：依赖注入IOC与DI的最基本实现

- spring-beans ： Bean 工厂与 bean 的装配

- spring-context ： spring 的 context 上下文即 IoC 容器

- spring-context-support

- spring-expression ： spring 表达式语言

2.spring中的IOC

IOC是 Inverse of Control 的简写，意思是控制反转。是降低对象之间的耦合关系的设计思想。

DI 是 Dependency Injection 的缩写，意思是依赖注入 , 说的是创建对象实例时，同时为这个对象注入它所依赖的属性

2.1配置:



<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>



<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>



<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-beans</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>



<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context-support</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>



<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-expression</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>

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

</beans>

2.3 对象创建的方式

(1) 无参构造

public class User {

private String name; public User() {

System.out.println("user无参构造方法");

}

public void setName(String name) {

this.name = name;

}

public void show(){

System.out.println("name="+ name );

} }

-------------------------------------------------------------

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

<bean id="user" class="com.zx.pojo.User">

<property name="name" value="zx"/>

</bean>

</beans>

(2) 有参构造

public class UserT {

private String name; public UserT(String name) {

this.name = name;

}

public void setName(String name) {

this.name = name;

}

public void show(){

System.out.println("name="+ name );

} }

-------------------------------------------------------------



<bean id="userT" class="com.zx.pojo.UserT">



<constructor-arg index="0" value="zhangsan"/>

</bean>



<bean id="userT" class="com.zx.pojo.UserT">

 <constructor-arg name="name" value="kuangshen2"/>

</bean>



<bean id="userT" class="com.zx.pojo.UserT">

<constructor-arg type="java.lang.String" value="kuangshen2"/>

</bean>

(3) 静态方法创建对象

public Person(String name , Car car){

this.name = name;

this.car = car;

System.out.println("Person 的有参构造方法 :"+name+car);

}

<bean name="person" class="com.zx.spring.bean.Person">

<constructor-arg name="name" value="rose"/>

<constructor-arg name="car" ref="car"/>

</bean>

// 静态工厂模式

public class PersonFactory {

public static Person createPerson(){

System.out.println(" 静态工厂创建 Person");

return new Person();

}

}

-------------------------------------------------------------

<bean name="pf" class="com.xzk.PersonFactory" factory-method="createPerson" />

(4) 非静态工厂方法

public class Users{

public Person createPerson1(){

System.out.println(" 非静态工厂创建 Person");

return new Person();

}

}

-------------------------------------------------------------

<bean id="u2" class="com.bean.Users"></bean>

<bean id="u3" factory-method="createPerson1" factory-bean="u2"></bean>

2.4 springBean 的生命周期

1 ）根据配置情况调用 Bean 构造方法或工厂方法实例化 Bean 。

2 ）利用依赖注入完成 Bean 中所有属性值的配置注入。

3 ）如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。

4 ）如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。

5 ）如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用。

6 ）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的预初始化方法 postProcessBeforeInitialzation() 对 Bean 进行加工操作，此处非常重要， Spring 的 AOP 就是利用它实现的。

7 ）如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法。初始化 bean的时候执行，可以针对某个具体的 bean 进行配置。 afterPropertiesSet 必须实现 InitializingBean 接口。实现 InitializingBean 接口必须实现 afterPropertiesSe 方法。

8 ）如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。

9 ）如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时， Bean 已经可以被应用系统使用了。

10 ）如果在中指定了该 Bean 的作用范围为 scope="singleton" ，则将该 Bean 放入 Spring IoC 的缓存池中，将触发 Spring 对该 Bean 的生命周期管理；如果在中指定了该 Bean 的作用范围为 scope="prototype"，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期， Spring 不再管理该 Bean。

11 ）如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。

2.5别名:

<alias name="userT" alias="userNew"/>

3.DI注入值

分类:一种是调取属性的set方法赋值，第二种使用构造方法赋值

3.1 set注入值

1 基本属性类型值注入

<property name="name" value="jeck" />

2 引用属性类型值注入(对象)

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

3.2 构造注入:

3.2.1 可以通过 name 属性，按照参数名赋值

public Person(String name , Car car){

this.name = name;

this.car = car;

System.out.println("Person 的有参构造方法 :"+name+car);

}

--------------------------------------------------------------------------------------

<bean name="person" class="com.zx.spring.bean.Person">

<constructor-arg name="name" value="rose"/>

<constructor-arg name="car" ref="car"/>

</bean>

3.2.2 可以通过index属性，按照参数索引注入

<bean name="person2" class="com.zx.spring.bean.Person">

<constructor-arg name="name" value="helen" index="0"></constructor-arg>

<constructor-arg name="car" ref="car" index="1"></constructor-arg>

</bean>

3.2.3 使用type注入

public Person(Car car, String name) {

super();

System.out.println("Person(Car car, String name)");

this.name = name;

this.car = car;

}

public Person(Car car, Integer name) {

super();

System.out.println("Person(Car car, Integer name)");

this.name = name + "";

this.car = car;

}

<bean name="person2" class="com.xzk.spring.bean.Person">

<constructor-arg name="name" value="988" type="java.lang.Integer" >

</constructor-arg>

<constructor-arg name="car" ref="car" ></constructor-arg>

</bean>

3.3spel spring表达式(#)

<bean name="car" class="com.zx.spring.bean.Car" >

<property name="name" value="mime" />

<property name="color" value=" 白色 "/>

</bean>



<bean name="person1" class="com.xzk.spring.bean.Person" p:car-ref="car">

<property name="name" value=" # {car.name}"/>

<property name="age" value=" # {person.age}"/>

</bean>

3.4 p命名空间注入值

使用 p: 属性名完成注入 , 走 set 方法

- 基本类型值 : p: 属性名 =" 值 "

- 引用类型值 : P: 属性名 -ref="bean 名称 "

实现步骤 : 配置文件中添加命名空间 p

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

---------------------------------------------------

<bean id="u6" class="com.entity.Users" p:age="30" p:name=" 李四 " p:student- ref="stu1">

</bean>

3.5 复杂类型注入



<property name="arrs">

<list>

<value>数组1</value>



<ref bean="car"/>

</list>

</property>



<property name="list">

<list>

<value>集合1</value>



<list>

<value>集合中的集合1</value>

<value>集合中的集合2</value>

<value>集合中的集合3</value>

</list>

<ref bean="car" />

</list>

</property>



<property name="map">

<map>

<entry key="car" value-ref="car" />

<entry key="name" value="保时捷" />

<entry key="age" value="11"/>

</map>

</property>



<property name="properties">

<props>

<prop key="name">pro1</prop>

<prop key="age">111</prop>

</props>

</property>

3.6 自动注入(由程序自动给属性赋值)

autowire ：

no 不自动装配 ( 默认值 )

byName 属性名 =id 名，调取 set 方法赋值

byType 属性的类型和 id 对象的类型相同，当找到多个同类型的对象时报错，调取 set 方法赋值

constructor 构造方法的参数类型和 id 对象的类型相同 , 当没有找到时，报错。调取构造方法赋值

示例 :

<bean id="service" class="service.impl.UserServiceImpl" autowire="constructor">

</bean>

配置全局自动装配 :

<beans default-autowire="constructor/byName/byType/no">

4.注解实现IOC

（ 1 ）配置文件中添加约束

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

http://www.springframework.org/schema/context

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

(2)配置注解扫描:指定扫描包下所有类中的注解,扫描包时,会扫描包所有的子孙包

<context:component-scan base-package="com.xzk.spring.bean"></context:component-

scan>

(3)注解

3.1 添加在类名上

@Component("对象名")

@Service("person") // service 层

@Controller("person") // controller 层

@Repository("person") // dao 层

@Scope(scopeName="singleton") // 单例对象

@Scope(scopeName="prototype") // 多例对象

3.2 添加在属性上 :

@Value("属性值")

private String name;

@Autowired // 如果一个接口类型，同时有两个实现类，则报错，此时可以借助 @Qualifier("bean

name")

@Qualifier("bean name")

private Car car;

// 说明 :@Resource 是 java 的注释 , 但是 Spring 框架支持 , @Resource指定注入哪个名称的对象

//@Resource(name=" 对象名") == @Autowired + @Qualifier("name")

@Resource(name="baoma")

private Car car;

3.3 添加在方法上

@PostConstruct //等价于init-method属性

public void init(){

System.out.println(" 初始化方法 ");

}

@PreDestroy // 等价于 destroy-method 属性

public void destroy(){

System.out.println(" 销毁方法 ");

}

5.Aop介绍

AOP（Aspect Oriented Programming)即面向切面编程。即在不改变原程序的基础上为代码段增加新的功能。应用在权限认证、日志、事务。

AOP 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

5.1.spring 中使用 aop

(1) 添加 jar 包

<dependency>

<groupId>aopalliance</groupId>

<artifactId>aopalliance</artifactId>

<version>1.0</version>

</dependency>

<dependency>

<groupId>org.aspectj</groupId>

<artifactId>aspectjweaver</artifactId>

<version>1.8.13</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-aspects</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-aop</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-core</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-beans</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context-support</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>

(2) 添加项目原有的调取过程

(3) 创建增强类 ( 本质上就是一个普通类 )

// 前置通知：目标方法运行之前调用 aop:before

// 后置通知 ( 如果出现异常不会调用 ) ：在目标方法运行之后调用 aop:after-returning

// 环绕通知：在目标方法之前和之后都调用 aop:around

// 最终通知 ( 无论是否出现异常都会调用 ) ：在目标方法运行之后调用 aop:after

// 异常增强 : 程序出现异常时执行 ( 要求：程序代码中不要处理异常 ) aop:after-throwing

(4) 添加 aop 命名空间

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

http://www.springframework.org/schema/aop

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

(5) 设置配置文件

<bean name="userService" class="com.xzk.spring.service.UserServiceImpl" />



<bean name="myAdvice" class="com.xzk.spring.aop.MyAdivce" />



<aop:config>

<aop:pointcut id="pc" expression="execution(* com.xzk.spring.service.ServiceImpl.*.* (..))"/>

<aop:aspect ref="myAdvice">

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

<aop:after-returning method="afterReturning" pointcut-ref="pc" />

<aop:around method="around" pointcut-ref="pc" />

<aop:after-throwing method="afterException" pointcut-ref="pc" />

<aop:after method="after" pointcut-ref="pc" /> </aop:aspect>

</aop:config>

注意 :(1) 环绕增强需要使用 ProceedingJoinPoint 作为参数 (2) 注意标签顺序

5.3. 切入点方法的定义

表达式匹配规则举例：

public * addUser(com.pb.entity.User) ： “*” 表示匹配所有类型的返回值。

public void *(com.pb.entity.User) ： “*” 表示匹配所有方法名。

public Object around(ProceedingJoinPoint point) throws Throwable{

point.proceed();

}

public void addUser (..) ： “..” 表示匹配所有参数个数和类型。

* com.pb.service.*.*(..)：匹配com.pb.service 包下所有类的所有方法。

* com.pb.service..*(..) ：匹配 com.pb.service 包及子包下所有类的所有方法

5,4 . 如何获取切入点信息

通过 JoinPoint 对象获取信息 :

System.out.println(" 切入点对象 :"+jp.getTarget().getClass().getSimpleName());

System.out.println(" 切入点方法： "+jp.getSignature());

System.out.println(" 切入点的参数： "+jp.getArgs()[0]);

5.5. 特殊的前置增强 -->Advisor 前置增强实现 步骤

5.6. 使用了 AspectJ 依赖注解开发

spring AOP 的注解方式：

1 ）增强类也需要创建对象 ( 使用 @Component)

2) 要启动扫描 spring 注解包的代码 :

<context:component-scan base-package="com.zx"></context:component-scan>

<1> 除了启动 spring 的注解之外还要启动 aspectJ 的注解方式

<aop:aspectj-autoproxy/>

<2> 在切面类 ( 增强类 ) 上添加： @Aspect

<3> 定义一个任意方法

@Pointcut("execution(* com.*.*(..))")

public void anyMethod( ){

//可以为空方法体

}

为什么要定义一个任意方法？？？因为 @Pointcut 要求要放在一个方法

例子:

@Pointcut("execution(* com.*.*(..))")

public void anyMethod(){

}

@Before("anyMethod()")

public void log(JoinPoint){

System.out.println("myAspect....log....before");

}

@Around("anyMethod()")

public void aroundTest(ProceedingJoinPoint pjp){

System.out.println("around...before....");

try {

pjp.proceed();// 执行目标方法

} catch (Throwable e) {

e.printStackTrace();

}

System.out.println("around...after....");

}

6.Spring事务管理

6.1什么是事务(Transaction)

通过 sql 将逻辑相关的一组操作绑定在一起，以便服务器保持数据的完整性 ( 准确性 ) 。

事务通常是以 begin transaction 开始，以 commit 或 rollback 结束。

事务执行的流程 : 开启事务 -> 执行 insert,update,delete->commit/rollback

6.2 为什么要使用事务？

(1) 为了提高性能

(2) 为了保持业务流程的完整性

(3) 使用分布式事务

6.3 事务的特性 ACID

1 - 原子性（ atomicity ）

事务是数据库的逻辑工作单位，而且是必须是原子工作单位，对于其数据修改，要么全部执行，要么全部不执行。

2 、一致性（ consistency ）

事务在完成时，必须是所有的数据都保持一致状态。在相关数据库中，所有规则都必须应用于事务的修

改，以保持所有数据的完整性。

3 、隔离性（ isolation ）

一个事务的执行不能被其他事务所影响。企业级的数据库每一秒钟都可能应付成千上万的并发访问，因而带来了并发控制的问题。

4 、持久性（ durability ）

一个事务一旦提交，事务的操作便永久性的保存在 DB 中。即使此时再执行回滚操作也不能撤消所做的更改

6.4 事务的嵌套 -> 传播行为 propagation

事务的传播机制

事务的第一个方面是传播行为（ propagation /,pr ɒ p ə ' ɡ e ɪʃə n/ behavior ）。

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。

规定了事务方法和事务方法发生嵌套调用时事务如何进行传播

例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。

Spring 定义了七种传播行为：

13.5 事务的隔离级别 MySQL 数据库共定义了四种隔离级别：

1. Serializable( 串行化 ) ：可避免脏读、不可重复读 , 幻读情况的发生。

2. Repeatable read( 可重复读 ) ：可避免脏读、不可重复读情况的发生。

3. Read committed( 读已提交 ) ：可避免脏读情况发生。

4. Read uncommitted( 读未提交 ) ：最低级别，以上情况均无法保证。

Isolation.DEFAULT: 为数据源的默认隔离级别

6.6需要包在pom

<dependency>

<groupId>org.aspectj</groupId>

<artifactId>aspectjweaver</artifactId>

<version>1.8.13</version>

</dependency>

.6.7 添加 tx 命名空间

6.8 添加配置在xml里面



<bean id="transactionManager"

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

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

</bean>



<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>





<tx:method name="save*" propagation="REQUIRED" />



<tx:method name="find*" propagation="SUPPORTS" read-only="true" />

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut id="txPointCut" expression="execution(* com.service.*.* (..))" />

<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>

</aop:config>

6.9使用注解方式添加事务

使用 @Transactional 注解 - 添加 tx 命名空间

@Transactional // 对业务类进行事务增强的标注

@Service("accountService")

public class AccountServiceImpl implements AccountService {}

配置xml

在默认情况 , <tx:annotation-driven /> 中 transaction-manager 属性会自动使用名为

"transactionManager" 的事务管理器 .

所以 , 如果用户将事务管理器的 id 定义为 transactionManager , 则可以进一步将①处的配置简化为

<tx:annotation-driven />.

6.10 @Transactional 其他方面介绍

6/11 使用不同的事务管理器

一般情况下 , 一个应用仅需要使用一个事务管理器 . 如果希望在不同的地方使用不同的事务管

理 ,@Transactional 注解同样支持 !

实现代码 :

@Transactional("事务管理器的名字") //此处添加指定事务管理器的名字

@Service("accountService")

public class AccountServiceImpl implements AccountService {}

<bean id="transactionManager"

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

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

<qualifier value=" 定义事务管理器的名字 , 可以被注解查找 " />

</bean>

7 Spring-jdbc

12.2. Spring 管理 JdbcTemplate

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-jdbc</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>

<dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

<version>5.1.46</version>

</dependency> 2. 测试

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-tx</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>5.0.8.RELEASE</version>

</dependency>

<dependency>

<groupId>com.mchange</groupId>

<artifactId>c3p0</artifactId>

<version>0.9.5.2</version>

</dependency>

7.2. Spring 管理 JdbcTemplate

注意 : 可以自己在 RoleDaoImpl 中添加 JdbcTemplate 变量 , 如果不自动装载记得添加变量的 set 方法 ,

标准的操作 , 我们可以让 RoleDaoImpl 继承 JdbcDaoSupport

public class RoleDaoImpl extends JdbcDaoSupport implements RoleDao {

public void save(Role role) {

String sql = "INSERT INTO role (rname,alias) value (?,?) ;";

getJdbcTemplate().update(sql,role.getRname(),role.getAlias());

}

}

----------------------------------------------------

配置文件 : 需要创建数据源和给 RoleDaoImpl 中的 jdbcTemplate 赋值

<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

p:jdbcUrl="jdbc:mysql://localhost:3306/xzk"

p:driverClass="com.mysql.jdbc.Driver"

p:user="root"

p:password="111"

/>



<bean name="jdbcTemplate"

class="org.springframework.jdbc.core.JdbcTemplate">

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

</bean>

<bean name="roleDao" class="com.xzk.spring.dao.impl.RoleDaoImpl">

<prope rty name="jdbcTemplate" ref="jdbcTemplate"/>
</bean>

7.3 创建db.properties属性文件

<context:property-placeholder location="db.properties" system-properties-mode="FALLBACK" > </context:property-placeholder>

p:jdbcUrl="${jdbc.jdbcUrl}"

p:driverClass="${jdbc.driverClass}"

7.4 JdbcTemplate常用方法:

JdbcTemplate.update(sql,ArgsObj....); // 多个参数值时，可以使用对象数组

jdbcTemplate.queryForObject(String var1, RowMapper var2, Object... var3);//查单个

jdbcTemplate.query(String var1, RowMapper var2, Object... var3); // 查询所有

getJdbcTemplate().query(sql,new BeanPropertyRowMapper< 类名 >( 类名 .class));// 查询 ( 单行 + 多行 )

实例：查询行数

String sql="select count(*) from users";

Integer integer = getJdbcTemplate().queryForObject(sql, Integer.class);

查询多列

Map<String, Object> map = jdbcTemplate.queryForMap(" select count(*),max(roleid),min(roleid) from role");

Set<Map.Entry<String, Object>> entrySet = map.entrySet();

Iterator<Map.Entry<String, Object>> iterator = entrySet.iterator();

while(iterator.hasNext()){

System.out.println(iterator.next());

}

查询单列值

String sql="select username from users";

List<String> list = getJdbcTemplate().queryForList(sql, String.class);

By CaesarChang 张旭合作: [email protected]

~关注我带你看更多精品技术和面试必备

号码 1153132260

1 Spring介绍:

Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将 面向接口的编程思想贯穿整个系统应用。