SSH框架简介+C3P0连接池（个人学习笔记非教程）

前言：本人在学习过程中喜欢写一点自己的体会与心得，遂挂到csdn上分享一下，有错误欢迎评论区或私信指出

SSH框架简介

• Spring+Struts+Hibernate(虽然已经过时，但并不成为我们不学它的理由，因为我们有着更好的理由去学习它)

• Spring+SpringMVC+Mybatis

  ​

  常见软件框架

  1. mvc
  2. mvp
  3. mvvm
  4. mvvp

SSH是 struts+spring+hibernate的一个集成框架，是目前比较流行的一种Web应用程序开源框架。

1. 框架是什么
2. ssh各有哪些功能

采用SSH开发模型，不仅实现了视图、控制器与模型的彻底分离，而且还实现了业务逻辑层与持久层的分离。这样无论前端如何变化，模型层只需很少的改动，并且数据库的变化也不会对前端有所影响，大大提高了系统的可复用性。而且由于不同层之间耦合度小，有利于团队成员并行工作，大大提高了开发效率。

高内聚，低耦合（来自知乎回答）

1. 高内聚

   所谓高内聚是指一个软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一责任原则。

2. 耦合度

   也称块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块的独立性则越差。模块间耦合高低取决于模块间接口的复杂性、调用的方式及传递的信息。

   • 耦合度 是松还是紧 就看你的 关联 是强还是弱，也就是修改的代价。

Hibernate

​ Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

Struts2

​ 本质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。Struts 2是Struts的下一代产品，是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。其全新的Struts 2的体系结构与Struts的体系结构差别巨大。Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与ServletAPI完全脱离开，所以Struts 2可以理解为WebWork的更新产品。虽然从Struts 1到Struts 2有着太大的变化，但是相对于WebWork，Struts 2的变化很小（百度百科）

spring

目的：解决企业应用开发的复杂性

范围：任何Java应用

简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的一站式容器框架

一站式框架

• web层：spring的MVC
• Service层：spring的ioc
• dao层：spring的jdbcTemplate

控制反转(IoC)

• Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它

    把对象的创建不是通过new方式实现，而是交给spring配置创建类对象
  

IoC底层原理

• xml配置文件

• dom4j解析xml（一个Java的XML API）

• 工厂设计模式

• 反射机制

new属于静态编译：编译的时候把你所有的模块都编译
反射属于动态编译：只有到运行时才会去获得该对象的实例,

创建步骤

1. 导入jar包
2. 创建类，在类里面创建方法
3. 创建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.xsd">

    <bean id="user" class="com.Crack.domain.User"></bean>

</bean

@Test
public void testUser(){
    ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
    User user=(User)context.getBean("user");
    user.add();
}

bean的基本属性

• id

• name：基本功能和id一样可以使用_ #

• class：类的全路径

• scop：bean的作用范围

  1. singleton：默认值
  2. prototype：配置Action是要用到多例模式
  3. request：域
  4. session：域
  5. globalSession：web项目中，应用在Prolet环境，如果没有Prolet环境那么globalSession相当于session一般用于实现单点登录

  ​

bean实例化的三种方式

• 使用类的无参构造函数实现（多）
• 使用静态工厂创建
• 使用实例工厂创建

<bean id="user" class="com.Crack.domain.User"></bean>

<bean id="user2" class="com.Crack.domain.UserFactory" factory-method="getUser"></bean>

<bean id="factory" class="com.Crack.domain.UserFactory"></bean>
<bean id="user3" factory-bean="factory" factory-method="getUser2"></bean>

属性注入操作

• 向类的属性设置值

属性注入的三种常用方式

• 调用有参构造函数实现
• 调用类的set方法
• 使用接口注入：spring不支持

<constructor-arg name="userName" value="李四"></constructor-arg>

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

p名称空间注入

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

p:name="xioami"

复杂类型注入

• 数组
• list集合
• map集合
• properties类型

1. 生成set方法
2. xml配置

<property name="Name" >
    <list>
        <value>1</value>
        <value>1</value>
        <value>1</value>
        <value>1</value>
    </list>
</property>

<property name="list">
    <list>
        <value>1</value>
        <value>1</value>
        <value>1</value>
    </list>
</property>

<property name="map">
    <map>
        <entry key="1" value="2"></entry>
        <entry key="1" value="2"></entry>
        <entry key="1" value="2"></entry>
        <entry key="1" value="2"></entry>
    </map>
</property>

<property name="properties">
    <props>
        <prop key="drive">com.mysql.jdbc.Driver</prop>
        <prop key="username">root</prop>
        <prop key="passwd">root</prop>
    </props>
</property>

IoC和DI区别

IoC：控制反转

DI：依赖注入，向类中属性设置值（不能单独存在，在IoC基础之上）

Spring的bean管理（注解）

注解：

1. 代码里的特殊标记，使用可以完成功能
2. 注解写法：@注解名称（属性名称=值）
3. 注解使用在类上面，方法和属性上面，替代部分配置文件

注解开发准备

注解创建对象

1. 导入jar包：spring-aop-4.3.15.RELEASE.jar
2. 创建类，创建方法
3. 创建xml，引入约束
4. 开启注解扫描

<?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.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- bean definitions here -->
    <context:component-scan base-package="com.Crack.domain"></context:component-scan>
</beans>

到包里扫描类，方法，属性上面是否有注解

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

注解写法

@Component(value = "user") //<bean id ="" class =""></bean>

衍生注解

• Component ：mapper（对象持久化映射层）

• Controller ：web层

• Service ：业务层

• Repository ：持久层

功能基本一样 ，便于以后拓展

配置单实例模式


注解方式注入属性

1. 自动注入（不需要set方法）

@Autowired

2. Resource注入

@Resource(name = "userdao")

配置文件和注解混合使用

---

#AOP操作

1. aop概述
2. aop底层原理
3. aop操作相关术语

aop概述

• struts拦截器使用了aop 纯java实现 不需要专门的类加载器 在运行的时候向目标类织入增强代码
• 面向切面编程 扩展功能不修改源码实现
• 采用横向抽取机制，取代传统纵向继承体系重复性代码
• 


aop底层原理

动态代理（Proxy）

• 代理模式的作用是 ：为其他对象提供一种代理以控制对这个对象的访问
• 对真实类的封装对于粒度的控制有着重要的意义
• 在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
• 用来做方法的增强，让你可以在不修改源码的情况下，增强一些方法
• 参考《java帝国之动态代理》
• JDK里的InvocationHandler接口的invoke方法

aop操作相关术语

• Joinpoint（连接点）：是指那些被拦截到的点。在spring中这些点指的是方法，因为spring只支持方法类型的连接点，简而言之就是类中能被增强的方法

• Pointcut（切入点）：指我们要对哪些连接点拦截。实际增强的方法被称为切入点

• Advice（通知，增强）：拓展的功能逻辑成为增强

  前置通知

  后置通知

  异常通知：方法出现异常

  最终通知：在后置之后执行

  环绕通知

• Aspect（切面）：把增强应用到具体方法之上，过程成为切面

• Introduction（引介）：不修改代码的前提下，在运行期为类动态地添加一些方法或属性

• Weaving（织入）：把增强应用到目标对象的过程

• Proxy（代理）：一个类被增强后产生一个结果代理类

AspectJ实现Spring AOP

1. AspectJ：面向切面的框架
2. aspectj不是spring的一部分，和spring一起使用进行aop操作
3. spring2.0之后新增了对Aspectj支持

使用aspectj实现aop有两张方式

1. 基于aspectj实现aop的xml配置
2. 添加aop约束41.２.７

<?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->

</beans>

<bean id="book" class="com.Crack.domain.Book"></bean>
<bean id="myBook" class="com.Crack.domain.MyBook"></bean>

<aop:config>
    <!--配置切入点-->
    <aop:pointcut expression="execution(* com.Crack.domain.Book.*(..))" id="pointcut1"></aop:pointcut>

    <!--配置切面-->
    <aop:aspect ref="myBook">
        <aop:before method="before1" pointcut-ref="pointcut1"/>
    </aop:aspect>
</aop:config>

基于aspectj实现aop的注解方式

通过注解实现

1. 创建对象

<bean id="book" class="com.Crack.aop.Book"></bean>
<bean id="myBook" class="com.Crack.aop.Mybook"></bean>

2. 开启aop操作

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

3. 在增强类中使用注解实现

@Aspect
public class Mybook {
    @Before(value = "execution(* com.Crack.aop.Book.*(..))")
    public void before1(){
        System.out.println("before1 add----");
    }
}

JdbcTemplate

代码实现

DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/user");
dataSource.setUsername("root");
dataSource.setPassword("root");

//创建jdbcTemplate对象，设置数据源
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

String sql = "select * from user.info where name=?";
User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(), "bob");
System.out.println(user.getName());

C3P0连接池

1. C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。
2. 首先，c3p0是一种jdbc数据库连接池。那么为什么使用数据库连接池呢？因为数据库连接是一种关键的、有限的、昂贵的资源。传统的模式（如传统的javaweb项目中，servlet的beans中建立数据库连接），每次连接都需要验证用户，消耗了大量的时间和资源。而数据库连接池在系统初始化的时候，将数据库连接作为对象存储在内存中，当用户需要访问数据库时，并非建立一个新的连接，而是从连接池中取出一个已经建立的空闲连接对象。使用完毕后，用户不关闭连接，而是将数据库连接对象放回连接池中。数据库连接池管理数据连接的建立、断开，同时监视数据库连接数量和使用情况。使用数据库连接池会显著提高整个应用程序的伸缩性（大大提高了连接数量）和健壮性（能够应对大量用户频繁连接数据库，减少系统资源的消耗），提高应用程序的性能指标。

• 配置c3p0连接池

• 导入jar包

  

• 常规代码配置方式创建连接池

ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setDriverClass("com.mysql.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/user");
dataSource.setUser("root");
dataSource.setPassword("root");

• 配置方式配置连接池

<bean id="datasource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/user"></property>
    <property name="user" value="root"></property>
    <property name="password" value="root"></property>
</bean>

<bean id="userservice" class="UserService">
    <property name="userDao" ref="userDao"></property>
</bean>


<bean id="userDao" class="UserDao">
    <property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>


<bean id="jdbcTemplate" class="JDBCTemplate">
    <property name="dataSource" ref="datasource"></property>
</bean>

public class UserDao {
    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void add(){
        String sql ="insert into user.info value(?,?)";
        int rows=jdbcTemplate.update(sql,"123","123");
        System.out.println(rows);
    }
}

public class UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void add(){
        userDao.add();
    }
}

—未完待续 ----