一spring概念和ioc入门（ioc操作xml配置文件）
1)spring概念
1.spring核心两部分
2.spring一站式框架
1.spring在javaee在三层结构中，每一层都提供不同的实现技术
Web是 springmvc
Service层 spring的ioc
dao层是spring的jdbcTemplete
3.spring版本
Spring 4.x
4.spring核心主要两部分
aop面向切面编程，扩展功能不是修改源代码实现
Ioc 控制反转
为什么会有spring?他能给我们带来什么样的好处
比如一个类，在类里面有方法（不是静态的方法），调用里面的方法创建对象
使用对象调用方法，创建类对象的过程，需要new出来对象
把对象的创建不是通过new方式实现,而是交给spring配置创建类的对象
2）spring的入门
1.ioc的原理
1.把对象的创建交给spring进行管理
2.ioc的注解方式
2.Ioc的底层原理实现的技术
1.xml配置文件
2.dom4j解决xml
3.工厂设计模式
4.反射
3.public class User{
Public void add(){.........}
}
//缺陷 耦合程度太高
使用工厂方法
Public class Factory{
Public static User getUser(){
Return new User();
}
}
// 还是耦合程度太高
思想:高内聚，低耦合
Ioc原理
Public class UserService{
}
Public class UserServlet{
//得到UserSerivice的对象
//new 创建
}
第一步 创建xm配置文件，配置要创建
D对象类
1.<bean id=”userService” class=””></bean>
第二步：创建工厂类，使用dom4j解析配置文件，反射
Public class Userservice{
1.//使用dom4j解析xml文件
//跟据id值 userSerivice得到id值对应的class属性值
String classvluae=”class属性值”
//2.使用反射创建对象
Class clas=Class.forName();
UserSerivice service=clas.newInstance();
}
降低类与类之间的耦合度
第三步：
2.ioc的入门案例
第一步：引入jar包
做基本的功能需要bean context el core
第二步：创建类 在类里面创建一个方法
Public static class User(){
public void mian(String[] args){
}
}
第三步：创建spring配置文件 配置创建对象
1.spring核心配置文件和位置不是固定
建议官方applicationContext.xml
2.引入约束 schem
Doc-spring-framework-reference-html 最后一文件 从后往前找
3.配置
Id名字随便器
Class 类的全路径信息 package+class
<bean id=”” class=””></bean>
第四步：写段代码测试类的创建
ApplicationContext context=new ClassPathXmlApplicationContext(“spring配置文件”)
Context.getBean(“id值”)；
3.解决配置文件没有展示的问题
1.上网可以解决
2.复制约束的位置
Myeslipse--->属性中--->xml c --add location “约束的文件位置”
3)spring的bean管理（xml配置文件）
1 bean实例化三种方式
1.在spring中通过配置文件的方式来创建
2.bean实例化三种方式实现
1.用无参数构造
2.使用静态工厂，返回类对象
1.创建一个对和一个工厂等对象
<bean id=”xx” class=”静态工厂的全路径” factory-method=”静态工厂返回对象的方法名称”></bean>
3.使用事例工厂
1.创建不是静态方法，返回对象
//创建工厂对象
<bean id=”xx” class=”工厂的全路径” ></bean>
//创建bean
<bean id=”xxx” facoty-bean=”xx” factory-mothed=”事例工厂的名称”></bean>
2.bean标签常用的属性
Id: 表示名称 任意名字
Id 属性值，不包含特殊的符号
Class：创建对象所在类的全路径
Name：功能 id 属性是一样
Name属性值 ：可以包含特殊符号
Scope属性（范围）：
singleton 单例 默认
Prototype: 多实例对象
Request 创建对象request域中
Session 创建对象ssession域中
globalSession 创建对象 globalSession中跟单点登录类似
3.属性的注入方式介绍
创建对象的时候，向类里面的属性设置值
第一种 set方法注入
例如
public class User(){
Private String name；
Private void setName(String name){
This.name=name;
}
}
第二种 使用构造有参数的方法注入
第三种 使用接口注入
4.spring注入属性（有参构造和set方法）
1.set方法注入
<bean id=”” class=””>
//name 表示类中属性的名称
//value表示属性的值
<porperty name=”” vlaue=””>
</bean>
2.有参数的构造方法
<bean id=”” class=””>
<constructor-arg name=”username” value=””>
</constructor-arg>
</bean>
5.spring注入对象类型属性
1.通过属性注入 sevice对象
<bean id=”” class=””>
<porperty name=”” ref=”dao层对象”>
</bean>
2.在serice创建dao对象 生成 set方法
6 p名存空间的注入
在一个标签中不能写多个相同的属性
Xmlns:p=”http://www.spring-framework.org/schema/p”
<--p名称空间的注入->
<bean id=”” class=”” p:属性的名字=””>
7 spring注入复杂的数据 有set完成注入
<bean id=”” class=””>
1.数组集合 name表示属性的名字
<property name=””>
<list>
<value>
...................
</list>
</property>
2.lis集合
<property name=””>
<list>
<value>
...................
</list>
</property>
3.map集合
<property name=””>
<map>
<entry key=”” vlaue=””></emtry>
...................
</map>
</property>
4.配置文件Properties
<property name=””>
<props>
<prop key=”driverclass”> com.mysql.jdbc.Driver</prop >
...................
</props>
</property>
</bean>
4.ioc与di区别
1.ioc控制反转，把对象创建交个spring
2.di依赖注入，向类里面的属性中设置值
关系：使用依赖注入不能单独存在，需要在ioc基础之上完成操作
5.spring整合web
1.加载spring核心配置文件
2.服务启动的时候完成配置加载配置文件和创建对象
3.实现原理
1ServletContext对象
2.监听器
在服务器启动的时候为每个项目创建的时候的生成一个
ServletContext对象，使用监听器可以监听到对象什么时候创建加载spring配置文件，把配置文件配置
对象创建交给服务器--把创建出来的对象放到servletContext域对象里面（setAttribute方法中）获取对象的时候打到servletContext域得到（getAttribute()
二spring的ioc操作（注解）和aop概念()
1.spring的bean管理
1）使用注解创建对象
注解能用在社么地方 类 方法 属性
注解配置的步骤
第一步：导入jar包四个加log4j
第二步：aop的jar包
第三步创建spring的配置文件引入约束
1.Ioc beans约束
2.spring ioc注解约束 context
开启注解扫描
范围：到包里面扫描类，方法，属性上面是否有注解
base-package=”” 类所在的包 多个包可以用逗号也是用公共包
<context:component-scan base-package=””></context:component-scan>
第二种
开启注解扫面
他只会扫面类上面的
<content:annotation-config></content:annotation-config>
创建对象
在类上面加入
@Compment(value=””)
@Controller web层
@Sevice 业务层
@Repository 持久层
其实这个四个注解都是一样
@Scope(value=”prototype”) //指定类是单实例还是多实例
2）使用注解注入属性
第一步 创建service类 和dao类
第二步 在service中得到dao对象 无需提供set get方法
@Autowired 自动注入
底层值怎么找对象 是根据类名称去找 然后返回该类所对应的类对象
@Resource(name=””) //注入的那对象 注解dao创建里面的value值
3）xml和注解方式的混合使用
1.创建对象使用配置文件的形式
2.注入属性的用注解 @Resource（name=””） //配置文件中的id值
2 Aop
1）aop的概述
1>aop 面向切面编程
2>aop采用横向抽取机制，取代了传统
public class User{
Public void add(){
//添加逻辑
}
}
功能
添加数据之后添加日志的功能
添加之后，记录用户什么时候添加了那个用户
Public class BaseUser{
Public void write(){
}
}
Public class User extends BaseUser{
Public void add(){
//功能的扩展
//调用父类的方法实现日志的功能
在父类中中方法发生了改变子类中的方法也要发生改变
}
}
2）aop的底层原理
Aop动态代码方式实现
Public interface Dao{
Public void add();
}
Pubic class DaoImpl implements Dao{
Public void add(){
//添加逻辑
//动态代理 不是真正的对象 是他的代理对象
// 实现的功能和原来一样
}
}
//创建DaoImpl类平级类对象
这个对象不是真正的对象，代理对象实现的DaoImpl相同的功能
1.使用jdk动态，有接口的形式
第二种情况 没有接口情况
Public class User{
Public void add(){
//使用的cglib动态代理，没有接口的形式
}
}
//动态代理实现
创建User类的子类的代理对象
在子类里面调用父类的方法完成增强
3）aop操作相关的术语
Public class User{
Public void add(){}
Public void update(){}
Public void find(){}
Public void delete(){}
}
连接点：类里面那些方法可以被增强，这些方法称为连接点
切入点：在类里面可以有很对的方法被增强,比如实际操作中，只是增强了类里面的add方法，和update方法，实际增强的方法称为切入点
通知;增强：争强的逻辑，称为争强，比如扩展日志的功能，这个日志
功称为争强
前置通知 在方法之前执行
后置通知 在方法之后执行
异常通知 方法异常执行
最终通知 在后置之后执行
环绕通知 在方法之前和方法之后执行
切面：把增强用到具体的方法上面，过程称为切面
把增强加入到切入点上面
Introduction（引介）引介是一种特需的通知在不修改类的代码前提下可以在
运行期为类动态的添加一些方法或属性
Target(面标对象):代理的目标对象（要增强的类）
Weaving（织入）：把增强应用到目标的过程
把advice应到target的过程
Proxy（代理） 一个类被aop织入增强后，产生了一个结果代理类
3）spring的aop操作（基于acpectj的xml方式）2.1x
1.spring里面进行aop的操作，使用aspectj实现
Aspectj不是spring的一部分，和spring一起I使用进行aop操作
2.使用aspectj实现aop有两种方式
1.基于aspectj的xml配置
2.基于aspectj的注解的配置
3.实现的准备工作
第一步:除了导入基本打jar包之外，还需要导入aop相关的jar包
1. Aopaliance-1.0.jar
2.aspectjweaver-1.8.7.jar
3.spring-aop-4.2.4.RELEASE.jar
4.spring-aspects-4.2.4.RELEASE.jar
第二步：创建spring的配置
1. 导入aop的约束 aop
2. 创建两个类
<bean id=”” class=””></bean>
<bean id=”” class=””></bean>
<!--配置切入点->
<aop:config>
<!-配置切入点-->
expression=””表达式 需要被增强类的路径
Execution(* 空格 类的路径.*(..))
<aop:pointcut expression=”” id=”xx”/>
<！-配置切面->
<aop:aspect ref=”z增强的类” >
<aop:before method=”增强类方法的名字” pointcut-ref=”xx”>
<aop:before>
<aop:aspect>
</aop:config>
注意在环绕通知类中的方法参数加入 <ProceedingJoinPoint>
//需要加的前置通知
proceedingJoinPoint.proced();
//需要加入的后置通知
4）Log4j的介绍
1.log4j可以看淡程序运行过程中更详细的信息
2.使用
1. 导入log4j的jar包
2.复制log4j的配置文件，复制到src下面
3.设置的日志的级别
5）Spring整合web项目
1.出现的问题 每次访问action的时候，都会加载spring的配置文件
2.底层的使用监听器，servletcontext对象
3.在spring里面不需要我们自己写代码实现,都帮我们封装了
1.封装了一个监听器，我门只需要配置就行
2.导入spring整合web项目的jar包
1.spring-web
<listener>
<linstener-class>
org.springframework.web.context.ContextLoderListerer
</listener>
<listener>
2.指定加载spring文件位置 默认到WEB-INF/applicationContext.xml
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:指定spring文件的位置</param-value>
</context-param>
三jdbcTemplate和spring管理事务
1.基于aspectj的注解aop操作（会用）
第一步：创建对象
第二步：在spring aop的操作
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>>
第三步：在方法上面加载类的注解
在增强的类上面 @Aspectj
在方法上面
@Before
2.spring的jdbcTemplate的操作
1.spring框架是一站式框架
2.spring对不同的持久化层技术都进行了封装jdbcTemplate对jdbc的封装
JDBC org.springframework.jdbc.core.JdbcTemplate
Hibernate5.0 org.springwork.orm.hibernate5.HibernateTemplate
IBatis(MyBatis) org.springframework.orm.ibatis.SqlMapClientTemplate
JPA org.springframework.orm.jpa.JpaTemplate
2.spring的jdbc的操作
3.导入jdbc相关的jar包
1.增加
第一步：
1.spring-jdbc-4.2.4.RELEASE.jar
2.spring-tx-4.2.4.RELEASE.jar
第二步：实现操作
//创建对象设置数据库的信息
DriverManagerDataSource dataSource=new DriverManagerDataSource()
1.设置驱动 setDriverClassName();
2.设置url setUrl()
3.设置用户名 setUsername();
4.设置密码 setPassword();
//创建jdbcTemplate对象，设置数据库的信息
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource)
//调用jdbcTemplate对象里面的方法实现操作
String sql=”insert into user values(?,?)”
jdbcTemplate.update(sql,参数的信息);
2.修改
1.与查询前三步一样的
String sql=”update user set password=? where username=?”
jdbcTemplate.update(sql,参数的信息);
3.删除
1.与查询前三步一样的
String sql=”delete user where usernname=?”
jdbcTemplate.update(sql,参数的信息);
4.查询
1.与查询前三步一样的
2.jdbcTemplate实现查询，有接口RowMAPPER
jdbcTempleate针对这个这个接口自己写实现类
查询返回某一个值
Strng sql=”select count(*) from User”
queryForObject(String sql,Class requireType);
第一个是参数的sql语句
第二个参数，返回类型的class对象
查询返回一个对象
String sql=”select * from User whrer username=?”
queryforObject(Stirng sql,RowMapper<T> rowMapper,Object ..)
第一个参数是sql语句
第二个参数是RowMapper是接口，类似于dbutils里面的接口
第三个参数是sql语句中的注入的参数
Class MyRowMapper implements RowMapper<User>{
//该方法前面的操作都写了
@Overide
Public User mapRow(ResultSet rs,int num) throws SqlException{
//从结果集中获取数据 num代表数据库中有查询出来几条数据
Return user;
}
}
查询返回一个集合
String sql=”select * from User”
jdbcTemplate .query(sql ,new MyRowMapper())
3spring配置连接池
1.配置c3p0的连接池
<bean id=”dataSource” class=”com.mchage.v2.c3p0.ComboPooledDataSource”>
<property name=”driverClass” value=”com.mysql.jdbc.Driver”></property>
<property name-”jdbcUrl” value=”jdbc:mysql:///数据库的名称”></property>
<property name=”user” value=”root”></property>
<property name=”password” value=”root”></property>
</bean>
//创建userSerivice对象
<bean id=”userService” class=””>
<property name=”” ref=”userDao”>
<property name=”jdbcTemplate” ref=”jdbcTemplate”></property>
</property>
</bean>
//创建dao对象
<bean id=”userDao” class=””>
</bean>
//创建jabcTemplate
<bean id=”jdbcTemplate” class=”org.springframework.jdbc.core.JdbcTemplate”>
<property name=”dataSource” ref=”dataSource”><property>
</bean>
2.service和dao的注入操作
4.spring的事务管理
1.事务的概念
1.什么是事务
2.事务特性
3.不考虑隔离性产生读的问题
4.解决读的问题
1.设置隔离级别
2.spring进行事务管理api
1.spring进行事务配置（声明式）
基于xml配置文件
基于注解的方式
2.编程式事务管理
3.pring进行事务管理api
事务管理器PlatFormTransactionManger
Spring为不同的特性的持久框架提供不同PlatFromTransactionManger接口的实现
org.springframework.jdbc.datesource.DataSourceTransactionManger
使用spring jdbc或iBatis进行持久化使用
Org.springframework.orm.hibernate5.Hibernate.TransactionManger
使用Hibernate5.0版本的进行持久化数据使用
Org.springframework.orm.jpa.Jpa.TransactionManger 使用JPA进行持久化使用
Org.springframework.jdo.jdo.ransactionManger 使用持久化机制是jdo
Org.springframework。Transaction.jta.jtaTransactionManger
使用一个JPA实现管理事务，在一个事务跨越多个资源是必须使用
配置事务管理器
转账的操作
1.创建数据的表
2.创建一个serive和dao，完成操作
3.<bean id=”userSericie” class=””>
<propery name=”userDao” ref=”userDao”></property>
</bean>
<bean id=”userDao” class=””>
<property name=”jdbcTemplate” ref=”jdbcTemplate” ></property>
</bean>
<bean id=”jdbcTemplate” class=”org.springframework.jdbc.core.JdbcTemplate”>
<property name=”dataSource” ref=”dataSource”><property>
</bean>
Dao层类的
Public class UserDao{
Private JdbcTemplate jdbcTemplate;
//提供set方法
Public void lessMoney(){
//String sql=”update accout set salary=salary-? where username=?”;
jdbcTemplate.update(sql,100,”小王”)
}
Public void moreMoney(){
//String sql=”update accout set salary=salary+? where username=?”;
jdbcTemplate.update(sql,100,”小马”)
}
}
Serivice层
Public calss UserSerice{
//提供set方法
Private UserDao userDao；
Public void transformAccount(){
userDao.lessMoney();
userDao.moreMoney();
}
}
声明是事物管理 aop tx
第一步：创建事物管理器
<bean id=”transactionManger” class=”org.springframework.jdbc.datesource.DataSourceTransactionManger”>
<property name=”dataSource” ref=”dataSource”></property>
</bean>
第二步:配置事务德增强
<tx:advice id=”txadvice” transation-manager=”transactionManger”>
<tx:attribute>
<tx:methd name=”account*” propagation=”REQUIREQ”>
<tx:methd name=”inset*” propagation=”REQUIREQ”>
</tx:attribute>
</tx:advice >
第三步：配置切面
<aop:config>
<aop:pointcut expression=”execution(* 包.*(..))” id=”pointcut1”>
<aop:advisor advice-ref=”txadvice” pointcut-ref=”pointcut1”></aop:advisor>
</aop:config>
注解式事务管理
第一步: 配置事务管理器
<bean id=”transactionManger” class=”org.springframework.jdbc.datesource.DataSourceTransactionManger”>
<property name=”dataSource” ref=”dataSource”></property>
</bean>
第二步 开启事务管理器的注解
< tx:annotation-driven transaction-manager=”transactionManager” />
第三步 在需要加载事务的方法上面添加注解
@Transactional
四ssh框架整合开发
SSH框架的三大框架的整合
1.struts2
2 hibernate5.x
3.spring4.x
回顾SSH框架知识点
Hibernate框架
1.hibrenate核心的配置文件
Orm思想
核心配置文件
1.数据库的信息
2.hibernate信息
3.映射配置
4.hibernate核心配置文件
如果单纯的使用hibernate框架，核心的配置文件名称hibernate.cfg.xml
和位置的src下面 固定的
Hibernate和spring整和的时候,hibernate核心的配置文件的名称和位置没有固定的要求
2.hibernate映射文文件的
1.实体类和数据库的映射关系使用orm思想
2.hibernate操作步骤
在spring框架对hibernate框架进行封装的时候,HibernateTemplate
Struts 2
1. Action操作
1)action创建的三种方式
继承ActionSupport
2)配置actiion的访问路径
创建struts.xml的配置文件，这个文件名存和位置固定在src下面
3）配置访问action的多个方法
使用通配符方法配置
4）在action获取表单提交数据
获取request对象
使用ServletActionContext类对象
--属性的封装
--模型的驱动
5) 在action操作域对象
使用ServletActionContext获取域对象
6)配置struts2的过滤器
2.值栈
1.值栈存放数据
---set方法
--push方法
---定义变量，生成get方法
2.从值栈中获取数据
在jsp中使用struts2标签+ognl标签
<s:property>
<s:iterator>
3.拦截器
1.aop和责任链模式
2.自定义拦截器
--继承MehtodFilterInterceptor
重写类里面的方法
配置拦截器与action的关联
Spring 框架
1.spring核心配置文件
1)名称和位置文友固定的要求
2)在spring核心配置文件中引入schema约束
2.创建对象
1.xml配置的方式
2.注解的方式
3.使用ServletContext对象和监听器实现
1.在服务器启动的时候加载spring配置文件，创建对象
2.配置spring的监听器
4.jdbcTempalte
5.事务的方法
Ssh整合的思想
web struts2：
Service spring：
dao hibernate：
两个框架整合
Struct2框架和spring框架整合
1. 把Struct2 action对象的创建，交给spring管理
<bean id=” ” class=” ” scope=””>
2.导入整合的jar包
1.倒入spring的jar包
2.struts2-spring-plugin-2.3.24.jar
Spring-web
3.spring这个web项目
4.strut2德jar把
3.创建spring中action 然后在struts2种
<spring中的id值>
<action id=”userAcion” class=””><action>
Spring和hibenate整合
把hibernate核心配置文件里面的数据库的信息，直接写到spring配置文件中
第一次方法的很慢，因为第一次访问的时候创建sessionFactory对象
把sessionFactory对象的创建交给spring管理
在服务器启动的时候创建sessionFactory对象
具体实现
第一步:导入hibernate的jar包
1.导入struts2和hibernate的jar包时候有jar的冲突问题
在struts2里面有jar包
Javassist-3.11.0GA.jar
2.在hienrate里面有jar
Javassist-3.18.1-GA。Jar
删除低版本
2导入spring整盒持久化层的框架需要导入的jar包
Spring-orm--
第二步：spring里面镇对上面情况，封装类，配置类对象可以创建sessionFactory
<bena id=”sessionFactory” class=”org.springframework.orm.hibernate5.LocalSessionFactoryBean”>
<property name=”dataSource” ref=”dataSoruce”> </property>
<property name=”configLocations”value=”classpath:hibernate.cfg.xml”></property>
</bean>
Spring分模块开发
1.在spring里面配置多个内容，造成配置混乱，不利于维护
2.把spring核心配置文件中，一部分配置放到单独的配置文件中在spring
<引入其他的spring的配置文件
<import resource=”classpath:”/>
Spring框架和hibernate整合
