spring笔记整理

整理spring概念、ioc底层原理、bean管理、web整合

Spring的概念+ioc入门

Spring的概念：

是一个开源的轻量级框架【不需要依赖其他框架，可以直接使用的免费框架】

Spring是一个一站式框架：【web层+service层+dao层都可以使用spring完成】

Spring核心框架两部分

Aop：面向切面编程：扩展一个功能不需要修改源代码实现

Ioc：控制反转：比如有一个类的方法，非静态。调用类里边的方法，需要new一个对象，使用对象调用方法；把用spirng对象的创建不是通过new的方式创建，而是交给spring配置创建类对象。

Spring的一站式框架

Spring在javaee的三层结构中，提供了不同的解决技术，例如Hibernate是dao层，struts是web层。

 Web层：springMVC

 Servie层：spring的ioc

 Dao层：spring的jdbcTemplate

 

Spring的版本

Spring的版本用的是4.x的版本。

Hibernate使用的是5.x的版本。

Spring的入门：

Ioc的层原理

1. 把对象的创建交给spring进行管理：
   1. ioc的底层原理主要使用的xml配置文件
   2. dom4j解析xml文件
   3. 需要工厂的设计模式
   4. 需要反射的代码技术。

 

 

 

1. ioc操作两部分
   1. ioc的基于配置文件的操作
   2. ioc的基于注解的方式的实现

Ioc入门案例

1. 导入jar包
   1. 
   2. 
2. 创建类，在类里边定义方法
3. 创建spring配置文件，配置创建的类
   1. Spring核心配置文件的名称和位置是不固定的
   2. 建议放到src下边，官方命名为applicationContext.xml
   3. 引入约束schema
   4. D:\chromeDownLoad\spring-framework-4.2.4.RELEASE-dist\spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html
   5. 打开网页，最下边的是约束

1. xmlns="http://www.springframework.org/schema/beans"
2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.     xsi:schemaLocation="
4.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

1. 1. 配置操作：
   2. <bean id="user" class="com.pshdhx.spring.ioc.User">bean>
   3. 测试代码
   4. 测试使用ioc创建的对象

public void testUser() {         //加载spring核心配置文件，创建对象         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");         //根据id的值得到配置创建的对象         User user = (User)context.getBean("user");         user.add();

解决配置文件没有提示

1. spring引入schema约束，吧约束文件引入到eclipse中
2. 复制xsd路径http://www.springframework.org/schema/beans/spring-beans.xsd
3. 

 

Spring的bean管理（xml配置文件的方式）

Bean实例化的三种方式

Bean实例化的方式：在spring里边可以通过配置文件创建对象

1. 使用类里边的无参构造创建【重点：默认情况下有无参构造，如果有了有参构造，程序出错，必须手动加上无参构造】
   1. <bean id="user" class="com.pshdhx.spring.ioc.User">bean>
2. 使用静态工厂创建
   1. 创建静态方法，返回类的对象，看上面原理图
   3. <bean id="bean2" class="com.pshdhx.spring.ioc.StaticBean2Factory" factory-method="getStaticBean2">bean>
3. 使用实例工厂创建
   1. 创建不是静态的方法，返回类的对象

<bean id="abnormalFactory" class="com.pshdhx.spring.ioc.AbnormalFactory">bean>     <bean id="bean3"  factory-bean="abnormalFactory" factory-method="getAbnormalBean3">bea

Bean标签的常用属性

1. Id属性：标签起的名称，根据id值得到配置对象
2. Class属性：创建对象所在的全路径
3. Name属性：功能为id属性，name属性可以包含特殊符号，是struts的遗留问题
4. Scope属性：设置类的特点
   1. Singleton：默认的值，单例的，只能实例化一个对象。两个对象的话地址一样。
   2. Prototype:多例的，用户action的配置，action是多实例的
   3. Request：web项目中，spring创建一个bean对象，将对象存入到request中
   4. Session：web项目中，spring创建一个bean对象，将对象存入到session中
   5. Globalsession：web项目中，应用在porlet环境下，如果没有该环境，相当于session。可以用户单点登录，即登录百度文库也就是登录了百度贴吧，不需要重新登录。

属性注入方式的介绍

创建对象的时候，对类里边的属性设置值。

1. 有参构造
2. Set方法
3. 接口方式

在spring注入方式中，只提供set和有参方式注入。

Spring的注入属性（有参数构造和set方法）

          

    <bean id="propertydemo1" class="com.pshdhx.spring.ioc.ConstructorPropertyDemo">

        <constructor-arg name="username" value="pshdhx">constructor-arg>

    bean>

 

Spring注入对象类型属性（重点）

在action中注入service对象，实现set方法

 

在service中注入dao对象

    <bean id="userDao" class="com.pshdhx.spring.ioc.UserDao">bean>

    <bean id="userService" class="com.pshdhx.spring.ioc.UserService">

       

        <property name="userDao" ref="userDao">property>

    bean>

P名称空间注入

名称空间：在一个beans的标签中不能有多个相同的属性，后边加：+别名表示多个名称空间。

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

    <bean id="pNameSpace" class="com.pshdhx.spring.ioc.PNameSpace" p:username="pshdhx">bean>

但是PnameSpace的属性类中还得提供set方法。

Spring注入复杂数据

注入数组，list集合，map集合，properties类型

    <bean id="complexProperty" class="com.pshdhx.spring.ioc.ComplexProperty">

         

         <property name="arrs">

            <list>

                <value>pvalue>

                <value>svalue>

                <value>hvalue>

                <value>dvalue>

                <value>hvalue>

                <value>xvalue>

            list>

         property>

         

         <property name="list">

            <list>

                <value>ppvalue>

                <value>ssvalue>

                <value>hhvalue>

                <value>ddvalue>

                <value>hhvalue>

                <value>xxvalue>

            list>

         property>

         

         <property name="map">

            <map>

                <entry key="nihao" value="hello">entry>

                <entry key="好的" value="good">entry>

            map>

         property>

         

         <property name="properties">

            <props>

                <prop key="driverclass">com.mysql.jdbc.Driverprop>

                <prop key="username">rootprop>

            props>

         property>

    bean>

Ioc和di的区别

1. ioc控制反转：把对象的管理创建交给spring，解耦合
2. DI:依赖注入：向类里边的属性中设置值
3. 关系：依赖注入不能单独存在，需要在ioc的基础上完成操作

Spring整合web项目资源原理

1. 在本地加载applicationContext的时候，很慢

1) new对象，功能可以实现，效率很低

2实现思想:把加载配置文件和创建对象过程，在服务器启动时候完成

3实现原理

(1) ServletContext 对象

(2)监听器

(3)具体使用:

-在服务器启动时候，为每个项目创建-一个 ServletContext对象

-在ServletContext对象创建时候，使用监听器可以具体到ServletContext对象在什么时候创建

-使用监听器监听到ServletContext对象创建时候，4-加载spring配置文件，把配置文件配置对象创建

-把创建出来的对象放到ServletContext域对象里面( setAttribute方法)。-获取对象时候，到ServletContext域得到( getAttribute 方法)

整理spring的bean管理、注解、配置文件、aop底层原理、操作术语、aspectj的xml方式、log4j的介绍

spring的bean管理

使用注解创建对象

注解：

1. 代码里边的特殊标记，使用注解可以完成功能
2. 注解写法：@注解名称，属性名称=属性值
3. 可以用在类上班，方法上边，属性上边

准备工作：  导入基本jar包

                          导入aop的jar包spring-aop-4.2.4.RELEASE.jar

                          在核心配置文件中引入约束

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

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

 

类上边加注解：@Component(value="user")     //

 

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        User user = (User)context.getBean("user");

        user.add();

使用注解注入属性

@Component(value="userService")

public class UserService {

    @Autowired //自动装配

    private UserDao userDao;

    //注解方式不需要set方法

Xml和注解方式的混合使用

AOP

Aop概述

Aop底层原理

 

 

 

 

 

Aop操作相关术语

Spring的aop操作-基于aspectj的xml方式

Aspectj：是一个面向切面的框架，它扩展了java语言。Aspetj定义了aop语法所以他有一个专门的编译器用来生成遵守java字节编码的规范的Class文件。

Aspectj是一个基于java语言的框架

Spring2.0以后新增加了对Aspectj切点表达式的支持

@Aspectj是Aspectj1.5新增的功能，通过jdk5注解技术，允许直接再bean类中定义切面。

新版本spring框架，建议使用Aspectj方式开发aop

使用Aspectj需要导入SpringAop和Aspectj相关的包

Aop的操作准备：

1. 导入相关的jar包
2. 导入aop的约束

2. xmlns="http://www.springframework.org/schema/beans"
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.     xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
5.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
6.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
7.  

 

Aspectj的Xml配置

1. 切入点：实际增强的方法
2. 常用的表达式
   1. Execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
   2. Execution(任意修饰符* 包名.类名.方法名(…));
   3. Execution(任意修饰符* 包名.类名.*(…));
   4. Execution(*.*.*(…));
   5. 匹配所有save开头的方法 execution(* save*(…));

 

    <bean id="book" name="book" class="com.pshdhx.spring.aop.Book">bean>

    <bean id="enhanceClass" class="com.pshdhx.spring.aop.EnhanceClass">bean>

   

    <aop:config>

        <aop:pointcut expression="execution(* com.pshdhx.spring.aop.Book.*(..))" id="pointcut1"/>

        <aop:aspect ref="enhanceClass">

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

            <aop:after method="after1" pointcut-ref="pointcut1"/>

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

        aop:aspect>

    aop:config>

Aspectj的注解方式

Log4j介绍

整理spring的jdbcTemplate实现curd操作、spring配置连接池、事务管理、搭建转账环境

1. 基于aspecttj的注解aop操作
3. <aop:aspectj-autoproxy>aop:aspectj-autoproxy>
4. <bean id="book" class="com.pshdhx.spring.aopannotation.Book">bean>
5. <bean id="mybook" class="com.pshdhx.spring.aopannotation.Mybook">bean>

@Aspect

public class Mybook {

    @Before(value = "execution(* com.pshdhx.spring.aopannotation.Book.*(..))")

    public void before() {

        System.out.println("before");

    }

}

1. Spring的jdbcTemplate的操作

public class TestJDBCTemplate {

    @Test

    public void add() {

        //设置数据库信息

        DriverManagerDataSource dataSource = new DriverManagerDataSource();

        dataSource.setDriverClassName("com.mysql.jdbc.Driver");  //设置数据库的驱动

        dataSource.setUrl("jdbc:mysql:///spring_day03");

        dataSource.setUsername("root");

        dataSource.setPassword("123");

 

 //创建jdbctemplate对象，设置数据源

        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

     

 

        //调用jdbctemplate对象的方法实现操作

        String sql = "insert into user values(?,?)";

        int rows = jdbcTemplate.update(sql, "pshdhx","HelloWorld");

        System.out.println(rows);

    }

}

 

   

实现curd操作

//修改操作

    @Test

    public void update() {

        //设置数据库信息

                DriverManagerDataSource dataSource = new DriverManagerDataSource();

                dataSource.setDriverClassName("com.mysql.jdbc.Driver");  //设置数据库的驱动

                dataSource.setUrl("jdbc:mysql:///spring_day03");

                dataSource.setUsername("root");

                dataSource.setPassword("123");

               

                //创建jdbctemplate对象，设置数据源

                JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

               

               

                //调用jdbctemplate对象的方法实现操作

                String sql = "update user set password =? where username = ?";

                int rows = jdbcTemplate.update(sql, "hello","pshdhx");

                System.out.println(rows);

    }

//删除操作

        @Test

        public void delete() {

            //设置数据库信息

                   DriverManagerDataSource dataSource = new DriverManagerDataSource();

                   dataSource.setDriverClassName("com.mysql.jdbc.Driver");    //设置数据库的驱动

                   dataSource.setUrl("jdbc:mysql:///spring_day03");

                   dataSource.setUsername("root");

                   dataSource.setPassword("123");

                  

                   //创建jdbctemplate对象，设置数据源

                   JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

                  

                  

                   //调用jdbctemplate对象的方法实现操作

                   String sql = "delete from user where username=?";

                   int rows = jdbcTemplate.update(sql, "pshdhx");

                   System.out.println(rows);

        }

DBUtil

查询的实现：

查询返回某一个值

//查询操作

                @Test

                public void testCount() {

                   //设置数据库信息

                           DriverManagerDataSource dataSource = new DriverManagerDataSource();

                           dataSource.setDriverClassName("com.mysql.jdbc.Driver");  //设置数据库的驱动

                           dataSource.setUrl("jdbc:mysql:///spring_day03");

                           dataSource.setUsername("root");

                           dataSource.setPassword("123");

                          

                           //创建jdbctemplate对象，设置数据源

                           JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

                          

                          

                           //调用jdbctemplate对象的方法实现操作

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

                           int rows = jdbcTemplate.queryForObject(sql, Integer.class);

                           System.out.println(rows);

                }

查询返回某一个对象

//jdbc实现代码

                @Test

                public void testJDBC() {

                   java.sql.Connection conn = null;

                   java.sql.PreparedStatement pstmt = null;

                   ResultSet rs = null;

                   //加载驱动

                   try {

                       Class.forName("com.mysql.jdbc.Driver");

                       //创建连接

                       try {

                           conn = DriverManager.getConnection("jdbc:mysql:///spring_day03", "root", "123");

                           String sql = "select * from user where username = ?";

                           pstmt = conn.prepareStatement(sql);

                           pstmt.setString(1, "pshdhx");

                           rs = pstmt.executeQuery();

                           //遍历结果集

                           while(rs.next()) {

                               String username = rs.getString("username");

                               String password = rs.getString("password");

                              

                               User user = new User();

                               user.setUsername(username);

                               user.setPassword(password);

                               System.out.println(user);

                           }

                       } catch (SQLException e) {

                           // TODO Auto-generated catch block

                           e.printStackTrace();

                       }

                   } catch (ClassNotFoundException e) {

                       // TODO Auto-generated catch block

                       e.printStackTrace();

                   }finally {

                       try {

                           rs.close();

                           pstmt.close();

                           conn.close();

                       } catch (SQLException e) {

                           // TODO Auto-generated catch block

                           e.printStackTrace();

                       }

                      

                   }

                }

}

class User{

    private String username;

    private String password;

    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;

    }

    @Override

    public String toString() {

        return "User [username=" + username + ", password=" + password + "]";

    }

   

}

匿名内部类实现封装接口对象

//查询返回某个对象的方法

                @Test

                public void testObject() {

                   //设置数据库信息

                           DriverManagerDataSource dataSource = new DriverManagerDataSource();

                           dataSource.setDriverClassName("com.mysql.jdbc.Driver");  //设置数据库的驱动

                           dataSource.setUrl("jdbc:mysql:///spring_day03");

                           dataSource.setUsername("root");

                           dataSource.setPassword("123");

                          

                           //创建jdbctemplate对象，设置数据源

                           JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

                          

                          

                           //调用jdbctemplate对象的方法实现操作

                           String sql = "select * from user where username = ?";

                           User user = (User)    jdbcTemplate.queryForObject(sql, new rowMapper(),"pshdhx");

                           System.out.println(user);

                }      

class rowMapper implements RowMapper {

 

    @Override

    public User mapRow(ResultSet rs, int num) throws SQLException {

        String username = rs.getString("username");

        String password = rs.getString("password");

        User user = new User();

        user.setPassword(password);

        user.setUsername(username);

        return user;

    }

 

}

查询返回某一个list集合

 

    //查询返回某个List集合的方法

                @Test

                public void testList() {

                   //设置数据库信息

                           DriverManagerDataSource dataSource = new DriverManagerDataSource();

                           dataSource.setDriverClassName("com.mysql.jdbc.Driver");  //设置数据库的驱动

                           dataSource.setUrl("jdbc:mysql:///spring_day03");

                           dataSource.setUsername("root");

                           dataSource.setPassword("123");

                          

                           //创建jdbctemplate对象，设置数据源

                           JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

                          

                          

                           //调用jdbctemplate对象的方法实现操作

                           String sql = "select * from user ";

                           List list  = jdbcTemplate.query(sql, new rowMapper());

                           System.out.println(list);

                }      

添加，修改，删除操作都是update

查询时衍生了三种方法：

查询数量【】

查询对象

查询list集合

spring配置连接池

      配置c3p0连接池

• 这是c3p0数据库连接池的辅助包，如果没有这个包系统启动时会报classnotfoundexception，这是更新c3p0-0.9.2版本后分离出来的包，0.9.1的时候还是只是一个包。
• 1.c3p0是什么？
• c3p0是一个库。它扩展了传统的jdbc数据库连接池，并且支持JDBC3规范和JDBC2的标准扩展。
  2.为什么使用c3p0？
• 首先，c3p0是一种jdbc数据库连接池。那么为什么使用数据库连接池呢？因为数据库连接是一种关键的、有限的、昂贵的资源。传统的模式（如传统的java web项目中，servlet的beans中建立数据库连接），每次连接都需要验证用户，消耗了大量的时间和资源。而数据库连接池在系统初始化的时候，将数据库连接作为对象存储在内存中，当用户需要访问数据库时，并非建立一个新的连接，而是从连接池中取出一个已经建立的空闲连接对象。使用完毕后，用户不关闭连接，而是将数据库连接对象放回连接池中。数据库连接池管理数据连接的建立、断开，同时监视数据库连接数量和使用情况。使用数据库连接池会显著提高整个应用程序的伸缩性（大大提高了连接数量）和健壮性（能够应对大量用户频繁连接数据库，减少系统资源的消耗），提高应用程序的性能指标。
• 3.java web项目中部署c3p0（MyEclipse）

      Service和dao的注入操作

Spring的事务管理

事物概念

1. 什么是事务：一组操作，一个失败都失败
2. 事务的特性：：原子性 一致性 隔离性 和持久性
3. 不考虑隔离性产生读问题，设置隔离级别可以解决【多个事务之间不会产生影响】

Spring进行事物管理的api    

1. 编程式事务管理
2. 声明式事务管理
   1. 基于xml配置文件
   2. 基于注解

 

spring的事物处理

基于xml方式

Aop：的思想配置

   

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

       

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

    bean>

   

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

        <tx:attributes>

           

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

        tx:attributes>

    tx:advice>

   

    <aop:config>

        <aop:pointcut expression="execution(* com.pshdhx.spring.tx.UserService.*(..))" id="pointcut1"/>

        <aop:advisor advice-ref="txadvice" pointcut-ref="pointcut1"/>

    aop:config>

    <bean id="userService" class="com.pshdhx.spring.tx.UserService">

        <property name="userDao" ref="userDao">property>

    bean>

    <bean id="userDao" class="com.pshdhx.spring.tx.UserDao">

        <property name="jdbcTemplate" ref="jdbcTemplate">property>

    bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

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

    bean>

基础注解方式

1. 配置事务管理器
2. 配置事务的注解
3. 在要使用事务的类的上边中添加注解

 

 

搭建转账的环境

1. 创建数据库表，添加数据
2. 创建service和dao的类，完成注入的关系+模板jdncTemplate
3. 出现异常，进行事务回滚

         配置事务管理器

配置事务的增强

配置切面

简介SSH框架整合、action创建的三种方式、值栈、拦截器、Hibernate5.x，spring4.x，SSH框架整合思想

SSH框架的知识点

struts2

action创建

action创建的三种方式

1. 继承类actionsupport
2. 配置action的访问路径-配置sturts.xml配置文件，名称固定放到src下边去
3. 配置访问action的多个方法
   1. 使用通配符方式配置
4. 在action获取表单提交数据
   1. 获取request对象（最原始方式，功能最强大）
      1. 使用ServletActionContext类获取
   2. 属性封装
   3. 模型驱动（用的最多）,属性封装和模型驱动不能同时对一个表单进行操作，只会执行模型驱动
   4. 表达式封装
5. 在action操作域对象
   1. 使用ServletActionContext获取域对象
6. 配置struts2的过滤器

2、值栈

1、向值栈放数据

         Set方法

         Push方法

         定义变量，生成get方法

2、从值栈获取数据

         在jsp中使用struts2标签+ognl获取

        

        

3、拦截器

         Aop和责任链模式

         自定义拦截器

                  继承MethodFilterInterceptor

                  重写类方法，配置拦截器和action的关联

Hibernate5.x

Hibernate的核心配置文件

         如果单纯使用Hibernate框架，核心配置文件名称为Hibernate.cfg.xml和位置src是固定的。Hibernate和spring整合的时候，Hibernate和核心配置文件没有固定的要求

         实体类和数据库表的映射关系-使用orm思想

Orm思想：

对象关系映射

数据库信息

Hibernate信息

映射配置

Hibernate操作步骤：

         在spring框架对Hibernate框架进行封装，使用hibernateTemplate

 

Spring4.x

1. spring的核心配置文件
   1. 名称和位置没有固定要求
   2. 在spring核心配置文件中引入schema约束
2. 创建对象
   1. Xml配置方式
   2. 注解方式 四个注解
3. 注入属性
   1. Xml配置方式
   2. 注解方式 两个注解
      1. AutoWired
      2. resource
4. 使用ServletContext对象和监听器实现
   1. 在服务器启动的时候，加载spring配置文件，创建对象
   2. 配置spring的监听器
   3. 指定spring配置文件位置
5. jdbcTemplate
6. spring的事务的配置
   1. xml方式
   2. 注解方式

SSH框架整合思想

整合spring和struts2框架

整合web项目

整合hibernate

运用struts使用过滤器

引入约束

1. 导入jar包
2. 大家struts2环境
   1. 创建action，创建struts2.xml配置文件配置action
   2. 配置struts2的过滤器
3. 搭建hibernate环境
   1. 创建实体类
   2. 创建实体类和数据库表的映射关系 *.hbm.xml
   3. 创建hibernate的核心配置文件

在struts2.xml中引入映射文件

1. 搭建spring环境
   1. 创建spring核心配置文件
   2. 让spring配置文件 在服务器启动的时候加载
      1. 配置监听器
      2. 指定spring配置文件的位置
2. struts2和spring的整合
   1. 把action在spring配置
   2. 在struts.xml文件中action标签class属性写bean的id值
3. spring和hibernate的整合
   1. 把hibernate核心配置文件中的数据库配置在spring中配置
   2. 把hibernate的sessionFactory在spring中配置

 

Svn

r