Spring是J2EE应用程序框架，是轻量级的IOC和AOP的容器框架，主要针对javaBean的生命周期进行管理的轻量级容器，可以单独使用，也可以和Mbatis框架等组合使用。
Spring可以帮助我们管理bean的声明周期
SpringAOP可以让我们以更多的方式进行编程。也就是面向切面编程
集成其他框架，例如Spring Mvc,Mybatis
促进我们能有更好的编码方式
注意:
1.控制反转:当我们调用一个方法或者类，不再由我们主动去创建这个类的对象，控制权交给spring
2.依赖注入:spring主动创建被调用类的对象，然后把这个对象注入到我们自己的类中，使得我们可以使用它。
（依赖控制反转简单点说就是从new对象转化了使用spring对象）
接下来构建环境
1.下载支持包并添加到lib中
2.在src下创建配置文件，文件中创建bean节点
文档约束
<?xml version="1.0" encoding="UTF-8"?>
<!-- 添加约束 -->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
指定包(com.spring.day01.Stu_service_impl)下的类Stu_service_impl
package com.spring.day01;
import java.util.List;
import java.util.Map;
public class Stu_service_impl implements Stu_service {
/*普通属性*/
private int name;
/*数组*/
private int[] array;
/*list*/
private List<String> list;
/*map*/
private Map<Integer,String> map;
/*自定义数据*/
private Source source;
public Stu_service_impl() {
System.out.println("stu");
}
public Source getSource() {
return source;
}
public void setSource(Source source) {
this.source = source;
}
public Map<Integer, String> getMap() {
return map;
}
public void setMap(Map<Integer, String> map) {
this.map = map;
}
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
public int[] getArray() {
return array;
}
public void setArray(int[] array) {
this.array = array;
}
public void getname() {
System.out.println("getname被调用");
}
public int getName() {
return name;
}
public void setName(int name) {
this.name = name;
}
}
package com.spring.day01;
public class Source {
public Source() {
System.out.println("Source无参构造");
}
public Source(String s) {
System.out.println("Source有参构造1,"+s);
}
public Source(String s,int q) {
System.out.println("Source有参构造2");
}
public Source(int q,String s) {
this.fshu =s;
System.out.println("Source有参构造3");
}
private String fshu;
public String getFshu() {
return fshu;
}
/*public void setFshu(String fshu) {
this.fshu = fshu;
}*/
/*
* 如果将set方法去除
* 则无法反射到对应的属性，赋值失败
* 使用构造方法传值
*/
}
在创建的配置文件中添加bean节点
<!--添加节点-->
<bean id="stuserviceimpl" class="com.spring.day01.Stu_service_impl">
<!--添加属性-->
<!--普通数据类型-->
<property name="name" value="121" />
<!--数组-->
<property name="array">
<array>
<value>1</value>
<value>3</value>
<value>5</value>
<value>9</value>
</array>
</property>
<!--list-->
<property name="list">
<list>
<value>欢迎来到</value>
<value>这里</value>
</list>
</property>
<!--map-->
<property name="map">
<map>
<entry key="1" value="one" />
<entry key="5" value="yes" />
<entry key="8" value="wa" />
</map>
</property>
<!--自定义数据类型，需要ref引用自定义类型的bean节点id-->
<property name="source" ref="source"/>
</bean>
<bean name="source" class="com.spring.day01.Source" scope="prototype">
<!-- singleton 单例 默认值
prototype 原型
单例模式下，不会再创建对象
原型模式下，一个getbean方法创建一个对象
-->
<!--构造方法赋值-->
<!--<constructor-arg name="s" value="666" />-->
<!--当有多个构造参数时参数顺序不匹配，将其加上index控制给构造传入参数的顺序-->
<constructor-arg type="java.lang.String" value="这是有参构造参数2" index="1" />
<constructor-arg type="java.lang.String" value="11" index="0" />
</bean>测试：
1.通过配置文件初始化spring容器，在初始化容器时就创建了对象
ApplicationContext appContext = new ClasspathXmlApplication("beans.xml");2.通过application获取节点
类1 name = appContext.getBean("类1对应的id");3.调用方法
name.方法();
//通过配置文件，初始化spring容器 容器初始化时，自动创建了对象
ApplicationContext acontext = new ClassPathXmlApplicationContext("beans.xml");
//通过acontext获取节点
Stu_service_impl ssi = (Stu_service_impl) acontext.getBean("stuserviceimpl");
//调用方法
ssi.getname();
//普通数据
int name = ssi.getName();
System.out.println(name);
//数组
int[] arr = ssi.getArray();
for (int i : arr) {
System.out.print(i+" ");
}
System.out.println();
//list
List<String> list = ssi.getList();
for (String s : list) {
System.out.print(s+" ");
}
System.out.println();
//map
Map<Integer,String> map = ssi.getMap();
//获取key
Set<Integer> set = map.keySet();
//根据key获取value
for (Integer key : set) {
System.out.print(key+" ");
System.out.print(map.get(key)+" ");
}
System.out.println();
//自定义数据
Source su1 = ssi.getSource();
String fs1 = su1.getFshu();
System.out.println(fs1);那么spring如何操作数据库呢，同样的在配置文件中创建JdbcTemplate的bean节点以及连接池的bean节点
<!--添加JdbcTemplate节点-->
<bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--在创建JdbcTemplate对象时，需要传入构造参数连接池(我选用的是c3p0)-->
<constructor-arg name="dataSource" ref="c3p0id">
</bean>
<!--添加c3p0连接池bean节点-->
<bean id="c3p0id" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!--设置参数-->
<property name="driverClass" value="com.mysql.jdbc.Driver" />
<property name="JdbcUrl" value="jdbc:mysql://localhost:3306/stu" />
<property name="User" value="jf" />
<property name="password" value="121" />
</bean>
对应的测试
//初始化spring容器
ApplicationContext ac = new ClassPathXmlApplicationContext("beans2.xml");
//通过容器获取节点
JdbcTemplate jt = (JdbcTemplate) ac.getBean("jdbctemplateid");
/*
* 增删改
*/
//编写sql
String sql = "insert into user values(0,?)";
//执行sql
int row = jt.update(sql,"花花儿");
System.out.println(row);
/*
* 查
*/
//编写sql
String sqlc = "select * from user";
//执行sql
List<User> ulist = jt.query(sqlc, new RowMapper<User>(){
public User mapRow(ResultSet res, int row) throws SQLException {
//读取结果集
int id = res.getInt("id");
String name = res.getString("name");
//映射到实体类
User u = new User();
u.setId(id);
u.setName(name);
return u;
}
});
//遍历ulist
for (User u : ulist) {
System.out.println(u.getId()+" "+u.getName());
}
}
Spring两大核心思想
1.IOC：inverse of control 控制反转
DI：依赖注入
2.AOP：aspect oriented programming 面向切面编程
aop处理系统级功能，不修改源代码
aop术语
切面：增强的集合，将通知添加到切入点的过程
通知：增强
目标类：切入点
连接点：目标类中可以被增强的方法
切入点表达式：execution(* [方法全路径(..)]),表达式中的..代表的含义是：(任意参数 任意数量)
那么在xml中如何实现呢？
首先配置目标类
<!-- 配置目标类 -->
<bean id="psi" class="com.spring.aop.day02.Pen_Service_impl"/>
配置增强类
<!-- 配置增强类 -->
<bean id="action" class="com.spring.aop.day02.Action"/>
最后添加aop相关配置
<!-- 添加aop相关配置 -->
<aop:config>
<!-- 切入点配置
表达式：execution(* com.xyz.myapp.service.*.*(..))
-->
<aop:pointcut expression="execution(* com.spring.aop.day02.Pen_Service.pen(..))" id="point1"/>
<!-- 切面 引入增强类 -->
<aop:aspect ref="action">
<!-- 将增强中方法加入目标类中的切入点 -->
<!-- 前置通知 -->
<aop:before method="mcl" pointcut-ref="point1"/>
<aop:before method="ycl" pointcut-ref="point1"/>
<!-- 后置通知 目标方法返回后执行-->
<aop:after-returning method="mqb" pointcut-ref="point1"/>
<!-- 后置通知 最终通知 -->
<aop:after method="hsxx" pointcut-ref="point1"/>
<!-- 异常通知 -->
<aop:after-throwing method="mhl" pointcut-ref="point1"/>
<!-- 环绕通知 -->
<!-- <aop:around method="gz" pointcut-ref="point1"/> -->
</aop:aspect>
</aop:config>
最后测试即可。
如果涉及到了事务，也只需要声明即可
<!-- 配置事务管理器 -->
<bean id="dstm" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 引用属性c3p0 -->
<property name="dataSource" ref="c3p0"/>
</bean><!-- 添加事务注解扫描 -->
<tx:annotation-driven transaction-manager="dstm"/>
扫一扫
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
