开闭原则,然后通过统一的方式来获取配置的资

2019-08-10 作者:编程   |   浏览(125)

RESTful接口开发,restful接口

package com.aaaaaa.manager.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.aaaaaa.manager.pojo.Item;
import com.aaaaaa.manager.service.ItemService;

@Controller
@RequestMapping("item/interface")
public class ItemInterfaceController {
    // http://127.0.0.1/query/1?rows=2
    // @RequestParam:获取请求参数的数据(包括表单提交的数据),就是获取rows=2 的2
    // @PathVariable:获取请求url路径上的数据,就是1

    @Autowired
    private ItemService itemService;

    // 根据id查询 GET
    // http://manager.aaaaaa.com/rest/item/interface/{id}
    /**
     * 根据id查询
     * 
     * @param id
     * @return
     */
    @RequestMapping(value = "{id}", method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<Item> queryItemById(@PathVariable Long id) {
        try {
            Item item = this.itemService.queryById(id);
            // 查询成功,返回200
            // return ResponseEntity.status(HttpStatus.OK).body(item);
            // return ResponseEntity.ok().body(item);
            return ResponseEntity.ok(item);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 如果服务器出错,返回500
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
    }

    // 新增 POST
    // http://manager.aaaaaa.com/rest/item/interface
    /**
     * 新增
     * 
     * @param item
     * @return
     */
    @RequestMapping(method = RequestMethod.POST)
    // @ResponseBody:不加这个注解就会走视图解析器,返回页面,加这个注解就走转换器,返回数据
    // 加上@ResponseBody注解和返回ResponseEntity效果是一样的,都会走转换器,返回数据,所以使用任意一个即可,两个都用也没问题
    public ResponseEntity<Void> saveItem(Item item) {
        try {
            this.itemService.save(item);
            // 新增成功,返回201
            return ResponseEntity.status(HttpStatus.CREATED).build();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 如果服务器出错,返回500
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
    }

    // 更新 PUT
    // http://manager.aaaaaa.com/rest/item/interface
    /**
     * 更新
     * 
     * @param item
     * @return
     */
    @RequestMapping(method = RequestMethod.PUT)
    public ResponseEntity<Void> updateItem(Item item) {
        try {
            this.itemService.updateByIdSelective(item);
            // 修改成功,返回204
            return ResponseEntity.status(HttpStatus.NO_CONTENT).build();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 如果服务器出错,返回500
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
    }

    // 根据id删除 DELETE
    // http://manager.aaaaaa.com/rest/item/interface/{id}
    /**
     * 根据id删除
     * 
     * @param id
     * @return
     */
    @RequestMapping(value = "{id}", method = RequestMethod.DELETE)
    public ResponseEntity<Void> deleteItemById(@PathVariable Long id) {
        try {
            this.itemService.deleteById(id);
            // 删除成功,返回204
            return ResponseEntity.status(HttpStatus.NO_CONTENT).build();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 如果服务器出错,返回500
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
    }

}

 

package com.aaaaaa.manager.controller; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpStatus...

Tomcat配置连接c3p0连接池,

一、Tomcat配置JNDI资源

JNDI(Java Naming and Directory Interface),Java 命名和目录接口。

JNDI的作用就是:在服务器上配置资源,然后通过统一的方式来获取配置的资源。

我们这里要配置的资源当然是连接池,这样项目中就可以通过统一的方式来获取连接池对象了。

1、导包

  需将这三个jar包置于Tomcat/lib/目录下:c3p0-0.9.5.2.jar、mchange-commons-java-0.2.11.jar、mysql-connector-java-5.1.44-bin.jar(Driver实现类),此例连接的是MySQL数据库,如果连接的是oracle还需c3p0-oracle-thin-extras-0.9.5.2.jar。

2、配置context.xml及web.xml文件

  apache-tomcat-9.0.0.M26/conf/context.xml中添加第14到25行内容

 1 <Context reloadable="true">
 2 
 3     <!-- Default set of monitored resources. If one of these changes, the    -->
 4     <!-- web application will be reloaded.                                   -->
 5     <WatchedResource>WEB-INF/web.xml</WatchedResource>
 6     <WatchedResource>WEB-INF/tomcat-web.xml</WatchedResource>
 7     <WatchedResource>${catalina.base}/conf/web.xml</WatchedResource>
 8 
 9     <!-- Uncomment this to disable session persistence across Tomcat restarts -->
10     <!--
11     <Manager pathname="" />
12     -->
13   <!-- 新配置内容 -->
14     <Resource auth="Container" 
15      description="DB Connection" 
16      driverClass="com.mysql.jdbc.Driver" 
17      maxPoolSize="100" 
18      minPoolSize="2" 
19      acquireIncrement="2" 
20      name="jdbc/mysqlds-c3p0" 
21      user="root"
22      password="" 
23      factory="org.apache.naming.factory.BeanFactory" 
24      type="com.mchange.v2.c3p0.ComboPooledDataSource" 
25      jdbcUrl="jdbc:mysql://localhost:3306/mydb1" /> 
26 </Context>

参数说明:

  • name:指定资源名称,这个名称可随便给,在获取资源时需要这个名称;
  • factory:用来创建资源的工厂,这个值基本是固定的,不用修改;
  • type:资源的类型,我们要给出的类型是我们连接池的类型。
  • 其他参数为资源的属性。

  在项目中web/WEB-INF/web.xml 文件中添加配置第6至10行内容

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
 3          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
 5          version="3.1">
 6     <resource-ref>
 7         <res-ref-name>jdbc/mysqlds-c3p0</res-ref-name>  <!--与context.xml下的Resources的name属性一致-->
 8         <res-type>javax.sql.DataSource</res-type>
 9         <res-auth>Container</res-auth>
10     </resource-ref>
11 </web-app>

二、获取资源

 1 package servlet;
 2 
 3 import javax.naming.Context;
 4 import javax.naming.InitialContext;
 5 import javax.naming.NamingException;
 6 import javax.servlet.ServletException;
 7 import javax.servlet.annotation.WebServlet;
 8 import javax.servlet.http.HttpServlet;
 9 import javax.servlet.http.HttpServletRequest;
10 import javax.servlet.http.HttpServletResponse;
11 import javax.sql.DataSource;
12 import java.io.IOException;
13 import java.sql.Connection;
14 import java.sql.SQLException;
15 
16 @WebServlet(name = "AServlet",urlPatterns = "/AServlet")
17 public class AServlet extends HttpServlet {
18     protected void doGet(HttpServletRequest request, HttpServletResponse response)
19             throws ServletException, IOException {
20         //1、创建JNDI的上下文
21         try {
22             Context ctx = new InitialContext();
23             //2、查询出入口
24 //            Context envCtx = (Context) ctx.lookup("java:comp/env");
25          //3、再进行二次查询,找到我们的资源
26          //使用的是名称与<Resource>元素的name对应
27 //            DataSource dataSource = (DataSource) envCtx.lookup("jdbc/mysqlds-c3p0");
28             DataSource dataSource = (DataSource) ctx.lookup("java:comp/env/jdbc/mysqlds-c3p0");
29             Connection con = dataSource.getConnection();
30             System.out.println(con);
31             con.close();
32         } catch (NamingException e) {
33             e.printStackTrace();
34         } catch (SQLException e) {
35             e.printStackTrace();
36         }
37 
38     }
39 }

 

一、Tomcat配置JNDI资源 JNDI(Java Naming and Directory Interface),Java 命名和目录接口。 JNDI的作用就是:在服务器上配置...

Spring快速入门,

----------------------- Page 1-----------------------

Spring

业务逻辑框架。(作用于三层)

1.Spring提出了三层架构的设计思想。

2.

编写代码的时候需要符合的原则:

高低原则:高内聚、低耦合

开闭原则:对扩展开放、对修改关闭(不改变原有的代码添加新功能)

面向接口编程

使用Spring可以更好的帮助满足以上的原则。

3.提供很多的代码通用的支持 (工具类、对很多技术都有通用支持)

Spring-IOC

Inversion of Control (IoC) 控制反转

dependency injection (DI) 依赖注入

使用SpringIOC容器:

1导入jar

----------------------- Page 2-----------------------

  1 <dependency>

2   <groupId>org.springframework</groupId>

3   <artifactId>spring‐beans</artifactId>

4   <version>4.3.9.RELEASE</version>

5 </dependency>

6 <dependency>

7   <groupId>org.springframework</groupId>

8   <artifactId>spring‐context</artifactId>

9   <version>4.3.9.RELEASE</version>

10 </dependency>

11 <dependency>

12   <groupId>org.springframework</groupId>

13   <artifactId>spring‐context‐support</artifactId>

14   <version>4.3.9.RELEASE</version>

15 </dependency>

16 <dependency>

17   <groupId>org.springframework</groupId>

18   <artifactId>spring‐core</artifactId>

19   <version>4.3.9.RELEASE</version>

20 </dependency>

21 <dependency>

22   <groupId>org.springframework</groupId>

23   <artifactId>spring‐expression</artifactId>

24   <version>4.3.9.RELEASE</version>

25 </dependency>

26 <dependency>

27   <groupId>org.springframework</groupId>

28   <artifactId>spring‐instrument</artifactId>

29   <version>4.3.9.RELEASE</version>

30 </dependency>

2.配置配置文件

 1  applicationContext.xml

2  <bean id="bean的名称" class="对象的类型"/>

3.加载IOC容器

 1 ApplicationContext ac = new ClassPathXmlApplicationContext(

2                 "classpath:ioc/ioc01/applicationContext.xml");

3 ac.getBean("bean名称")  //获取IOC容器中管理的对象

IOC容器

IOC是一个存放对象(bean)容器,进行控制反转 (原来创建对象的过程是由类自己控制,创建对象的过程交个

IOC容器,控制权反转),用于代码的解耦和,增加代码的可维护性。

IOC容器知识点

1.IOC容器的类型

----------------------- Page 3-----------------------

BeanFactory(IOC核心)

实现类:XmlBeanFactory

使用该实现类需要传递一个参数 (Resource,可以理解为File封装,File的路径比较繁琐)

Resource:

ClassPathResource 表示资源在classpath下

FileSystemResource 表示资源在文件系统中

UrlResource 表示资源在网络上

ByteArrayResource 表示资源内存中

InputStreamResource 表示资源在流中

ApplicationContext

实现:

ClassPathXmlApplicationContext

表示容器配置文件在classpath下

 1 //建议使用方式

2 ApplicationContext ac = new 

ClassPathXmlApplicationContext("classpath:ioc/ioc02/applicationContext.xml");

FileSystemXmlApplicationContext

表示容器配置文件在文件系统中

 1 //建议使用方式

2 ApplicationContext ac = new 

FileSystemXmlApplicationContext("file:E:/applicationContext.xml");

2.IOC容器帮助我们完成工作

1.实例化

2.装配 (注入)

1.装配(基于getter和setter方法)

a.简单值装配

基本类型(8)以及其包装类:byte short int long float double char boolean

String 、Class、Resource

 1 <bean id="springBean" class="com.itany.spring_ioc.ioc03.SpringBean">

2   <property name="age" value="18"></property>

3   <property name="bytes" value="127"></property>

4   <property name="sex" value="m"></property>

5   <property name="name" value="admin"></property>

6   <property name="clazz">

7     <value>java.lang.String</value>

8   </property>

9 </bean>

b.其他的bean引用

----------------------- Page 4-----------------------

 1 <bean id="springBean" class="com.itany.spring_ioc.ioc04.SpringBean">

2   <property name="otherBean" ref="ob"></property>

3   <property name="otherBean1">

4     <ref bean="otherBean1" />

5   </property>

6 </bean>

c.集合类型

Array(数组)

 1 <!‐‐数组类型为简单值‐‐>

2 <list>

3     <value>简单值</value>

4  </list>

5 <!‐‐数组类型为其他bean的引用‐‐>

6 <list>

7     <ref bean="其他beanID"/>

8     <bean class="其他bean的类型"></bean><!‐‐匿名bean‐‐>

9  </list>

List

 1 <!‐‐List类型为简单值‐‐>

2 <list>

3     <value>简单值</value>

4  </list>

5 <!‐‐List类型为其他bean的引用‐‐>

6 <list>

7     <ref bean="其他beanID"/>

8     <bean class="其他bean的类型"></bean><!‐‐匿名bean‐‐>

9  </list>

Set

 1 <!‐‐Set类型为简单值‐‐>

2 <set>

3     <value>简单值</value>

4  </set>

5 <!‐‐Set类型为其他bean的引用‐‐>

6 <set>

7     <ref bean="其他beanID"/>

8     <bean class="其他bean的类型"></bean><!‐‐匿名bean‐‐>

9  </set>

Map

----------------------- Page 5-----------------------

  1 <!‐‐map key和value都是简单值‐‐>

2 <map>

3     <entry key="简单值" value="简单值"></entry>

4     <entry>

5         <key>

6             <value>简单值</value>  

7         </key>

8         <value>简单值</value>

9     </entry>

10 </map>

11  

12 <!‐‐map key和value都是其他bean的引用‐‐>

13 <map>

14     <entry key‐ref="其他bean的ID" value‐ref="其他bean的ID"></entry>

15     <entry>

16         <key>

17             <ref bean="其他bean的ID"/> 

18         </key>

19         <ref bean="其他bean的ID"/>

20     </entry>

21 </map>

Properties

 1 <props>

2      <prop key="key值">value值</prop> 

3 </props>

d.null的装配

 1 <property name="name">

2   <null/>

3 </property>

e.使用p命名空间进行装配(只能对简单值和其他bean的引用)

  1 1.给配置文件的头部添加

2   xmlns:p=""

3  

4 简单值

5 <bean id="springBean1" class="com.itany.spring_ioc.ioc03.SpringBean"

6         p:age="18" p:bytes="127" p:sex="m" p:name="admin" p:clazz="java.lang.String">

</bean>

7  

8  

9 其他bean引用

10 <bean id="springBean1" class="com.itany.spring_ioc.ioc04.SpringBean"

11         p:otherBean‐ref="ob" p:otherBean1‐ref="otherBean1">

12     </bean>

2.实例化

----------------------- Page 6-----------------------

IOC容器中Bean的生命周期

静态代码块-->实例化-->装配(setter方法)-->[init]-->使用 -->[destory]-->从容器中移除

 1 销毁容器

2     1.所有的方法都是在子类中。

3     

4     2.方法含有两种:       

5             ac.destory()    ‐‐‐>立即销毁容器

6             ac.registerShutdownHook();   ‐‐>代码正常结束后销毁容器

在代码获取文件资源:

 1     Test07.class.getResourceAsStream("/") ‐‐‐>获取的为classPath目录

2     Test07.class.getResourceAsStream("")  ‐‐‐>获取的为当前这个类 (Test07)所在的目录

3     Test07.class.getClassLoader().getResourceAsStream("")‐‐>获取的为classPath目录

3.实例化方式

a.构造方法

无参数

 1    <bean id="" class=""/>

有参数

1     <bean id="" class="">
 
2         <constructor‐arg index="参数的顺序" type="参数的类型">

3             <value>简单值</value>  

4             <ref bean="其他bean的id"/>

5         </constructor‐arg>

6     </bean>

b.静态工厂

无参数

 1     <bean id="" class="工厂类" factory‐method="工厂方法"/>

有参数

 1     <bean id="" class="工厂类" factory‐method="工厂方法">

2         <constructor‐arg index="参数的顺序" type="参数的类型">

3             <value>简单值</value>  

4             <ref bean="其他bean的id"/>

5         </constructor‐arg>

6     </bean>

c.实例工厂(通常情况至少含有两个bean)

----------------------- Page 7-----------------------

无参数

 1     <bean id="" factory‐bean="工厂bean" factory‐method="工厂方法"/>

有参数

 1     <bean id="" factory‐bean="工厂bean" factory‐method="工厂方法">

2       <constructor‐arg index="参数的顺序" type="参数的类型">

3             <value>简单值</value>  

4             <ref bean="其他bean的id"/>

5         </constructor‐arg>

6      </bean>

4.实例化的时机

IOC容器在什么时间点帮助我们常见对象。

BeanFactory:懒实例化Bean(创建IOC容器的时候不会对其中的Bean实例化,使用Bean对象的时候才会实

例化)

ApplicationContext:默认即时实例化 (创建IOC就会实例所有的Bean)

可以对其修改为懒初始化:

 1 <bean lazy‐init="true"/>    ‐‐‐>对于当前这个bean为懒实例化

2  

3 在IOC配置文件的头部添加  default‐lazy‐init="true"   表示当前IOC容器中的所有的bean都是懒实例化

5.bean的域

在IOC容器中Bean默认都为单例.

bean中的属性为线程不安全的。

 1 <bean scope="prototype"/>   ‐‐>将该bean变为多例

2  

3 如果将Bean变为多例,那么这个bean中配置了destory‐method的话,也不会调用

6.Resource

它就是一个File的封装.

它的实现含有:

ClassPathResource     表示资源在classpath下 

FileSystemResource    表示资源在文件系统中 

UrlResource           表示资源在网络上  

ByteArrayResource     表示资源内存中  

InputStreamResource    表示资源在流中   

Resource获取方式

1.直接new实现类

2.可以通过ac.getResource("")

----------------------- Page 8-----------------------

 1 ac.getResource("classpath:hibernate.cfg.xml");

2 ac.getResource("file:E:/Wildlife.wmv");

Resource类型的属性装配(简单值装配)

 1 <property name="resource" value="classpath:dataSource.properties"></property>

2  

3 <property name="resource" value="file:E:Wildlife.wmv"></property>

7.继承配置

如果两个以上类存在相同的属性,如果在装配的时候属性值也是装配一致,这个时候就可以使用继承配置.

  1     <!‐‐将相同的配置拿到一个bean中,需要将该bean配置abstract="true"(表示这个bean不会进行实例化)  

‐‐>

2     <bean id="parentBean" abstract="true">

3         <property name="name" value="admin"></property>

4     </bean>

5     

6     <!‐‐子bean对父bean进行引用  采用parent属性‐‐>

7     <bean id="springBean" class="com.itany.spring_ioc.ioc17.SpringBean"

8         parent="parentBean">

9         <property name="pwd" value="123"></property>

10     </bean>

  1. 自动装配(针对其他bean的引用)

对于其他bean引用如果不想配置,可以使用自动装配

1 <!‐‐
 
2 在bean中添加一个属性  autowire (默认default  no)

3         byName

4             1.对set方法的名称在IOC容器中需要存在一个bean的名称与之相同

5             2.存在这个bean类型必须和set方法参数的类型一致

6         byType

7             1.set方法参数的类型需要在IOC容器中存在Bean

8             2.存在的bean有且只能含有一个

9         constructor

10             1.需要一个包含自动装配属性的构造函数。

11             2.这种装配方式和set方法没有任何关系,只和构造函数有关系

12             3.采用ByName和ByType同时装配

13                     byName:Name是构造方法参数的名称

14                     byType:Tyoe是构造方法参数的类型

15 ‐‐>

16 <bean autowire=""/>

9.FactoryBean

编写代码创建对象,比配置IOC更加简单,但是我们又想编写代码创建对象,将该交个IOC容器管理,就可以使

用FactoryBean。

----------------------- Page 9-----------------------

1.实现接口FactoryBean 

    public SessionFactory getObject()   表示生成的对象过程 

    public Class<?> getObjectType()     表示生成对象的类型(为了保证兼容性存在,现在没有作

用) 

    public boolean isSingleton()        表示生成对象是否为单例 

     

2.将这个FacrotyBean配置到IOC容器中。

10.IOC容器中后处理器

[beanFacory后处理器]-->静态代码块-->实例化-->装配(setter方法)-->

[beforeInit]--->[init]---[afterInit]-->使用 -->[destory]-->从容器中移除

1.Bean的后处理器--BeanPostProcessor

1.后处理器的两个方法分别在初始化方法之前和初始化方法之后 (初始化方法可以不存在) 

2.后处理是对所有IOC容器中bean有效

1.实现接口BeanPostProcessor 

2.将这个后处理器添加到ioc容器

2.BeanFactory后处理--BeanFactoryPostProcessor

1.后处理器的在静态代码块之前调用 

2.后处理是对所有IOC容器中bean有效

1.实现接口BeanFactoryPostProcessor 

2.将这个后处理器添加到ioc容器

11.从Bean中获取容器

1.使用Bean让其实现接口ApplicationContextAware (BeanFctoryAware) 

2.将这个配置到Ioc容器.

12.读取配置文件

 1 <bean

2         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

3         <property name="location" value="classpath:dataSource.properties"></property>

4     </bean>

  1. 自定义转换器注册

----------------------- Page 10-----------------------

 1     <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">

2         <property name="customEditors">

3             <map>

4                 <entry key="java.util.Date" 

value="com.itany.spring_ioc.ioc24.editors.DateEditor"></entry>

5             </map>

6         </property>

7     </bean>

Spring-AOP

AOP(Aspect-Oriented Programming)面向切面编程.

定义:将交叉业务逻辑(基本功能相似,交织在代码各个角落)抽取出来变为切面,由不同AOP实现进行在适当

的时机 (编译期、运行期(常用))添加到适当的位置(切点)。

AOP的术语

切面 Ascpect: 交叉业务逻辑抽象出的业务接口。

通知 Advice: 切面的代码实现。(代码中需要真正实现)

连接点 J oinPoint: 切面的位置 (接口)

切点 PointCut: 真正位置实现,连接点的实现 (代码中需要实现的)

代理 Porxy : aop的原理 (动态代理)

目标对象,代理对象 Target : 通知添加类

织入: Weaving : 将通知添加到切点过程--织入过程

引入: Intruduction: 给类添加功能。对类引入新的方法

Spring-AOP

定义:将交叉业务逻辑(基本功能相似,交织在代码各个角落)抽取出来变为切面,Spring-AOP实现进行在

运行期,添加到切点的位置。

使用AOP的好处

1.将交叉业务逻辑和功能业务进行分离 (解耦和)。

2.只要要进行分离之后,代码就模块化了

1.方便维护。

2.不改变原有的代码的情况下动态添加新的功能(开闭原则)。

3.方便项目中的任务分配。

AOP的原理:代理模式

静态代理

动态代理 (AOP的原理)

Spring默认采用的为J DK的动态代理,如果没有目标类没有接口,采用就为cglib技术.

Spring-AOP(2.x--后处理器)

添加依赖

----------------------- Page 11-----------------------

  1 <dependency>

2   <groupId>org.springframework</groupId>

3   <artifactId>spring‐aop</artifactId>

4   <version>${spring.version}</version>

5 </dependency>

6 <dependency>

7   <groupId>org.springframework</groupId>

8   <artifactId>spring‐aspects</artifactId>

9   <version>${spring.version}</version>

10 </dependency>

11 <dependency>

12   <groupId>cglib</groupId>

13   <artifactId>cglib</artifactId>

14   <version>3.2.5</version>

15 </dependency>

1.编写通知

[2.编写切点(AspectJ表达式) 不需要编写]

3.织入

编写通知(就是一个普通类)

前置通知

表示给方法前添加功能。

 1     //第一种写法

2     public void methodName(){}

3  

4    //第二种写法

5     public void methodName(JoinPoint joinPoint){}

配置:

 1 <aop:config>

2     <aop:pointcut  expression="AspectJ表达式" id="pc"/>

3     <aop:aspect ref="通知的ID">

4         <aop:before method="前置通知的方法名称"  pointcut‐ref="pc"/> 

5     </aop:aspect>

6 </aop:config>

 

后置通知

表示方法正常结束后添加功能。

----------------------- Page 12-----------------------

 1     //第一种写法

2     public void methodName(){}

3  

4     //第二种写法

5     public void methodName(JoinPoint joinPoint){}

6  

7      //第三种写法

8     public void methodName(JoinPoint joinPoint,Object returnVal){}

配置

 1 <aop:config>

2     <aop:pointcut  expression="AspectJ表达式" id="pc"/>

3     <aop:aspect ref="通知的ID">

4         <!‐‐前两种方法的配置方式‐‐>

5         <aop:after‐returning method="后置通知的方法名称"  pointcut‐ref="pc"/> 

6          <!‐‐第三种方法的配置方式‐‐>

7         <aop:after‐returning method="后置通知的方法名称"  pointcut‐ref="pc"  returning="返回值

变量名称"/> 

8     </aop:aspect>

9 </aop:config>

异常通知

表示方法异常结束之后添加功能。

 1     //第一种写法

2     public void methodName(){}

3  

4    //第二种写法

5     public void methodName(JoinPoint joinPoint){}

6     

7    //第三种写法

8     public void methodName(JoinPoint joinPoint,Exception ex){}

配置

 1 <aop:config>

2     <aop:pointcut  expression="AspectJ表达式" id="pc"/>

3     <aop:aspect ref="通知的ID">

4         <!‐‐前两种方法的配置方式‐‐>

5         <aop:after‐throwing method="异常通知的方法名称"  pointcut‐ref="pc"/> 

6          <!‐‐第三种方法的配置方式‐‐>

7         <aop:after‐throwing method="异常通知的方法名称"  pointcut‐ref="pc"  throwing="异常变量

名称"/> 

8     </aop:aspect>

9 </aop:config>

环绕通知

表示给方法的前和方法后添加功能。

----------------------- Page 13-----------------------

编写环绕通知方法需要三个条件(在环绕通知,业务由用户自己调用)

 1 /**

2  *   1.需要Object类型的返回值

3  *   2.需要含有一个参数 ProceedingJoinPoint

4  *   3.需要抛出Throwable的异常

5  **/

6     public Object methodName(ProceedingJoinPoint joinPoint) throws Throwable{}

配置

 1 <aop:config>

2     <aop:pointcut  expression="AspectJ表达式" id="pc"/>

3     <aop:aspect ref="通知的ID">

4         <aop:around method="环绕通知的方法名称"  pointcut‐ref="pc"/> 

5     </aop:aspect>

6 </aop:config>

织入

创建IOC容器(需要引入aop命名空间)

1.配置目标类的bean

2.配置通知bean

3.织入

AspectJ表达式

  1     1.within(包名.类名) ‐‐‐‐>表示给这个类中的所有的方法添加功能

2     2.execution(方法)    ‐‐‐>表示给该批方法添加功能

3             execution(java.lang.String logout(java.lang.String))      拦截IOC容器中所有的

Bean,只要bean中存在execution里面的方法前面,就会添加通知.

4             execution(void login(java.lang.String,java.lang.String))

5             execution(* log*(..))

6                     1.(*)‐‐‐>任意类型的返回值,任意多个字符

7                     2.(..)‐‐>任意类型的参数

8             execution(* log*(..,java.lang.String))  

execution(*com.itany.spring_aop.aop02.service.impl.UserServiceImpl.login(..))

9 execution(* com.itany.spring_aop.aop04.service.impl.*ServiceImpl.*(..))

10     3.还可以使用not  and  or

11 execution(void login(java.lang.String,java.lang.String)) or execution(java.lang.String 

logout(java.lang.String))

12     4.注解

13         @annotation(注解类型)

14           1.自定义注解(空注解)(com.itany.spring_aop.aop04.annotation.Timer)

15           [email protected](com.itany.spring_aop.aop04.annotation.Timer)

Spring注解

ioc中的注解

前提条件:扫描包(需要context命名空间)

----------------------- Page 14-----------------------

将一个类对象添加IOC容器中

@Component

@Controller 如果类为Action层

@Service 如果类为Service层

@Repository 如果类为Dao层

默认会给bean设置一个名称:类名首字母小写

可以覆盖@Component(value "bean的名称")

装配

简单值装配:

@Value("值")

其他bean的引用

  1 //1.spring实现

2 @Autowired     ‐‐‐>根据byName和byType通知装配

3 如果装配不上    结合 @Qualifier (value="指定的bean的id") 用户自定义装配的bean

4   

5  //2.官方标准

6   @javax.annotation.Resource(name="ob")

7   

8  //3.jsr330标准

9   需要引入标准依赖  

10     <dependency>

11             <groupId>javax.inject</groupId>

12             <artifactId>javax.inject</artifactId>

13             <version>1</version>

14     </dependency>

15   

16   

17   @Inject   ==>@Autowired

18   @Named(value="ob")  ==>  @Qualifier

19  

集合类型装配

需要结合命名空间(util)

需要注解

@javax.annotation.Resource(name "资源名称")

资源配置:使用util命名空间

 1 <util:list id="ints">

2         <value>1</value>

3         <value>2</value>

4 </util:list>

初始化和销毁方法

----------------------- Page 15-----------------------

@PostConstruct

@PreDestory

 

bean的域

@Scope(value "prototype") -->类级别

aop 中的注解

  1.将目标类添加到IOC容器 (@Service) 

  2.给通知添加到IOC容器(@Componet) 

  3.配置切面   给通知添加@Aspect 

  4.配置pointcut   在通知中添加空方法,在该方法上添加@Pointcut("AspectJ表达式") 

  5.方法上配置通知类型 

      1.前置通知@Before("pointcut()")‐‐‐>pointcut方法名的()不能丢 

      2.后置通知@AfterRetuning(pointcut="",retuning="") 

      3.异常通知@AfterThrowing(pointcut="",throwing="") 

      4.环绕通知@Around("pointcut()") 

  6.配置解析AspectJ注解的后处理器 

    方式一:在IOC容器中添加 

      <bean 

class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"></bean> 

    方式二:(需要aop命名空间)在ioc容器中添加 

    <aop:aspectj‐autoproxy />

spring整合

spring和web的整合

核心思想:将IOC的初始化过程给WEB容器。

1.添加依赖

 1 <dependency>

2   <groupId>org.springframework</groupId>

3   <artifactId>spring‐web</artifactId>

4   <version>${spring.version}</version>

5 </dependency>

2.配置 web.xml

----------------------- Page 16-----------------------

1  
 
2     <!‐‐ 用户自定义配置文件 ‐‐>

3     <context‐param>

4         <param‐name>contextConfigLocation</param‐name>

5         <param‐value>classpath:applicationContext‐*.xml</param‐value>

6     </context‐param>

7  

8  

9     <!‐‐ 在启动tomcat时候初始化IOC容器 默认加载为/WEB‐INF/applicationContext.xml ‐‐>

10     <listener>

11         <listener‐class>org.springframework.web.context.ContextLoaderListener</listener‐

class>

12     </listener>

3.注入过程

dao--->service--->controller

spring和jdbc的整合

1.添加依赖

  1 <dependency>

2   <groupId>org.springframework</groupId>

3   <artifactId>spring‐jdbc</artifactId>

4   <version>${spring.version}</version>

5 </dependency>

6  

7 <!‐‐ 事务配置 ‐‐>

8 <dependency>

9   <groupId>org.springframework</groupId>

10   <artifactId>spring‐tx</artifactId>

11   <version>${spring.version}</version>

12 </dependency>

13 <!‐‐数据库驱动‐‐>

14 <dependency>

15   <groupId>mysql</groupId>

16   <artifactId>mysql‐connector‐java</artifactId>

17   <version>#{mysql‐driver.version}</version>

18 </dependency>

2.配置

1.配置dataSource (两种)

a.使用第三方的数据源

1.spring数据源的用法

----------------------- Page 17-----------------------

  1     <!‐‐使用spring提供数据源‐‐>

2     <!‐‐ 使用spring提供的数据源 不提供连接池 ‐‐>

3     <bean id="dataSource"

4         class="org.springframework.jdbc.datasource.DriverManagerDataSource">

5         <property name="driverClassName" value="${mysql.driver}"></property>

6         <property name="url" value="${mysql.url}"></property>

7         <property name="username" value="${mysql.username}"></property>

8         <property name="password" value="${mysql.password}"></property>

9     </bean>

10  

11 <!‐‐  工作中常用的一些数据源 dbcp c3p0 druid(德鲁伊)... ‐‐>

2.dbcp的用法

 1 <!‐‐添加依赖‐‐>

2 <dependency>

3   <groupId>org.apache.commons</groupId>

4   <artifactId>commons‐dbcp2</artifactId>

5   <version>2.1.1</version>

6 </dependency>   

  1 <!‐‐ 使用dbcp2 ‐‐>

2     <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">

3         <property name="driverClassName" value="${mysql.driver}"></property>

4         <property name="url" value="${mysql.url}"></property>

5         <property name="username" value="${mysql.username}"></property>

6         <property name="password" value="${mysql.password}"></property>

7         

8         <!‐‐ 连接池的配置 ‐‐>

9         <property name="initialSize" value="${dbcp.initialSize}"></property>

10         <property name="maxTotal" value="${dbcp.maxTotal}"></property>

11         <property name="maxIdle" value="${dbcp.maxIdle}"></property>

12         <property name="minIdle" value="${dbcp.minIdle}"></property>

13         <property name="maxWaitMillis" value="${dbcp.maxWaitMillis}"></property>

14     </bean>

3.druid数据源

 1 <dependency>

2   <groupId>com.alibaba</groupId>

3   <artifactId>druid</artifactId>

4   <version>1.1.3</version>

5 </dependency>

----------------------- Page 18-----------------------

  1 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">

2   <property name="driverClassName" value="${mysql.driver}"></property>

3   <property name="url" value="${mysql.url}"></property>

4   <property name="username" value="${mysql.username}"></property>

5   <property name="password" value="${mysql.password}"></property>

6  

7   <property name="initialSize" value="${dbcp.initialSize}"></property>

8   <property name="maxActive" value="${dbcp.maxTotal}"></property>

9   <property name="maxWait" value="${dbcp.maxWaitMillis}"></property>

10   <property name="minIdle" value="${dbcp.minIdle}"></property>

11 </bean>

b.j ndi配置方式(将数据源交给web容器管理)

1.进入tomcat 目录conf (context.xml)

 1 <Resource name="user/dataSource" auth="Container"

2               type="javax.sql.DataSource"

3               factory="org.apache.commons.dbcp2.BasicDataSourceFactory"

4               driverClassName="com.mysql.jdbc.Driver" 

5               url="jdbc:mysql://127.0.0.1:3306/spring"

6               username ="root" />

2.在web程序中引用(web.xml)

1     <resource‐ref>
 
2         <res‐ref‐name>user/dataSource</res‐ref‐name>

3         <res‐auth>Container</res‐auth>

4         <res‐type>javax.sql.DataSource</res‐type>

5     </resource‐ref>

3.spring中使用j ndi (ioc容器的配置文件)

 1 <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">

2         <property name="jndiName" value="java:comp/env/user/dataSource"></property>

3 </bean>

4  

5 <!‐‐或者使用‐‐>

6 <jee:jndi‐lookup id="dataSource" jndi‐name="java:comp/env/user/dataSource"></jee:jndi‐

lookup>

3,注入过程

dataSource-->jdbcTemplate-->dao--->service--->controller

事务配置

事务的属性(五种)

1.传播属性(Propagation) 事务的边界

REQUIRED 添加事务,如果没有事务事务创建新的事务 (新增、删除、修改)

SUPPORTS 不会添加事务,如果存在事务也可以执行(查询)

----------------------- Page 19-----------------------

2.隔离属性(isolation)

READ_COMMITTED 不会发生脏读,但是可以发生幻读和不可重复读

READ_UNCOMMITTED 脏读、幻读、不可重复读都可以发生

REPEATABLE_READ 不会发生脏读,不可重复 但是可以发生幻读(mysql和oracle不支持)

SERIALIZABLE 不会发生脏读,不可重复、幻读

3.回滚条件

默认抛出RuntimeException

4.只读优化

read-only

5.超时处理

timeout

  1 <!‐‐事务管理器‐‐>

2 <bean id="transactionManager"

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

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

5 </bean>

6  

7 <!‐‐spring1.x版本的环绕通知  TransactionInterceptor‐‐>

8 <tx:advice id="transactionAdvice" transaction‐manager="transactionManager">

9         <tx:attributes>

10             <tx:method name="login" propagation="REQUIRED" isolation="DEFAULT" rollback‐

for="java.lang.Exception" read‐only="true" timeout="‐1"/>

11             <tx:method name="regist" propagation="REQUIRED"/>

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

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

14         </tx:attributes>

15 </tx:advice>

16  

17 <!‐‐织入‐‐>

18     <aop:config>

19         <aop:pointcut expression="execution(* org.itany.service.impl.*ServiceImpl.*(..))" 

id="pc"/>

20         <aop:advisor advice‐ref="transactionAdvice" pointcut‐ref="pc"/>

21     </aop:config>

使用注解配置事务

  1 <!‐‐事务管理器‐‐>

2 <bean id="transactionManager"

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

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

5     </bean>

6 <!‐‐事务的注解驱动‐‐>

7 <tx:annotation‐driven transaction‐manager="transactionManager"/>

8  

9 <!‐‐添加注解‐‐>

10 在需要添加事务方法上添加@Transactional(propagation=Propagation.REQUIRED)

----------------------- Page 20-----------------------

事务的并发会发生的一些错误:

脏读: 一个事务读取到另一个事务没有提交的数据。(mysql和oracle不会发生)

不可重复读: 读取的数据和数据库不一致 (一个事务在读取数据,另一个事务在修修改事务)

虚读/幻读: 读取的数据量和事务库不一致(一个事务在读取事务,另一个事务在删除或新增)

spring和mybatis整合

1.导入依赖(基于jdbc的依赖)

  1 <dependency>

2   <groupId>org.mybatis</groupId>

3   <artifactId>mybatis</artifactId>

4   <version>3.4.5</version>

5 </dependency>

6 <dependency>

7   <groupId>org.mybatis</groupId>

8   <artifactId>mybatis‐spring</artifactId>

9   <version>1.3.1</version>

10 </dependency>

2.注入流程

dataSource -->sqlSessionFactory--->Dao-->Service-->Controller

  1 <!‐‐sqlSessionFactory   mybatis的核心配置文件‐‐>

2 <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

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

4         <property name="typeAliasesPackage" value="org.itany.domain"></property>

5         <property name="mapperLocations" value="classpath:mapper/*Mapper.xml"></property>

6     </bean>

7  

8 <!‐‐Dao  在Mybatis中没有实现类型  使用的为代理模式‐‐>

9 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">

10         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>

11         <property name="basePackage" value="org.itany.dao"></property>

12     </bean>

spring和hibernate的整合

1添加依赖(基于jdbc的依赖)

----------------------- Page 21-----------------------

  1 <dependency>

2   <groupId>org.hibernate</groupId>

3   <artifactId>hibernate‐core</artifactId>

4   <version>5.2.9.Final</version>

5 </dependency>

6 <dependency>

7   <groupId>org.springframework</groupId>

8   <artifactId>spring‐oxm</artifactId>

9   <version>${spring.version}</version>

10 </dependency>

11 <dependency>

12   <groupId>org.springframework</groupId>

13   <artifactId>spring‐orm</artifactId>

14   <version>${spring.version}</version>

15 </dependency>

2.注入过程

dataSource--->SessionFactory--->Dao--->Service--->Controller

  1 <!‐‐sessionFactory‐‐>

2 <bean id="sessionFactory"

3         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">

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

5         <!‐‐ 可选配置 ‐‐>

6         <property name="hibernateProperties">

7             <props>

8                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>

9                 <prop key="hibernate.format_sql">true</prop>

10                 <!‐‐ 保证通过session.getCurrentSession()获取到的session为线程单例 ‐‐>

11                 <prop 

key="hibernate.current_session_context_class">org.springframework.orm.hibernate4.SpringSess

ionContext

12                 </prop>

13             </props>

14         </property>

15         <property name="packagesToScan">

16             <list>

17                 <value>org.itany.domain</value>

18             </list>

19         </property>

20     </bean>

对于post请求乱码处理:web.xml

----------------------- Page 22-----------------------

1 <!‐‐ 乱码 ‐‐>
 
2     <filter>

3         <filter‐name>encodingFilter</filter‐name>

4         <filter‐class>org.springframework.web.filter.CharacterEncodingFilter</filter‐

class>

5         <init‐param>

6             <param‐name>encoding</param‐name>

7             <param‐value>UTF‐8</param‐value>

8         </init‐param>

9     </filter>

10  

11     <filter‐mapping>

12         <filter‐name>encodingFilter</filter‐name>

13         <url‐pattern>/*</url‐pattern>

14     </filter‐mapping>

----------------------- Page 1----------------------- Spring 业务逻辑框架。(作用于三层) 1.Spring提出了三层架构的设计思想。 2. 编写代...

JDBC入门(5)--- 时间类型、大数据,jdbc入门

一、时间类型

数据库类型与Java中类型的对应关系:

DATE->java.sql.Date:表示日期,只有年月日,没有时分秒,会丢失时间。

TIME->java.sql.Time:表示时间,只有时分秒,没有年月日,会丢失日期。

TIMESTAMP->java.sql.Timestamp:表示时间戳,有年月日时分秒,以及毫秒。

  • 领域对象(domain)中的所有属性不能出现java.sql包下的对象,即不能使用java.sql.Date
  • ResultSet#getDate()返回的是java.sql.Date()
  • PreparedStatement#setDate(int,Date),其中第二个参数也是java.sql.Date

时间类型的转换:

  • java.util.Date ->java.sql.Date、Time、Timestamp
    • 把util的Date转换成毫秒值
    • 使用毫秒值创建sql的Date、Time、Timestamp
  • java.sql.Date、Time、Timestamp->java.util.Date 
    • 这一不不需要处理了:因为java.sql.Date是java.util.Date的子类。  
java.util.Date date = new java.util.Date();
long l = date.getTime();
java.sql.Date sqlDate = new java.sql.Date(l);

二、大数据

所谓大数据,就是大的字节数据,或大的字符数据。标准SQL中提供了如下类型来保存大数据类型:

类型 长度
tinyblob 28-1B(256B)
blob 216-1B(64K)
mediumblob 224-1B(16M)
longblob 232-1B(4G)
tinyclob 28-1B(256B)
clob 216-1B(64K)
mediumclob 224-1B(16M)
longclob 232-1B(4G)

 

 

 

 

 

 

 

但是,在mysql中没有提供tinyclob、clob、mediumclob、longclob四种类型,而是使用如下四种类型来处理文本大数据:

类型 长度
tinytext 28-1B(256B)
text 216-1B(64K)
mediumtext 224-1B(16M)
longtext 232-1B(4G)

 

 

 

 

实例:

 1 package demo4;
 2 
 3 import demo3.JdbcUtils;
 4 import org.apache.commons.io.IOUtils;
 5 import org.junit.Test;
 6 import javax.sql.rowset.serial.SerialBlob;
 7 import java.io.*;
 8 import java.sql.*;
 9 
10 public class Demo4 {
11     /**
12      * 把map3保存到数据库中、JdbcUtils为自建类
13      */
14     @Test
15     public void fun1() {
16         Connection con = null;
17         PreparedStatement pstmt = null;
18         Blob blob;
19         try {
20             con = JdbcUtils.getConnection();
21             String sql = "INSERT INTO tab_bin VALUES (?,?,?)";
22             pstmt = con.prepareStatement(sql);
23             pstmt.setInt(1,1);
24             pstmt.setString(2,"薛之谦-一半.mp3");
25             /**
26              * 需要得到Blob
27              * 1、我们有的是文件,目标是Blob
28              * 2、先把文件变成byte[]
29              * 3、再使用byte[]创建Blob
30              */
31             byte[] bytes = IOUtils.toByteArray(new FileInputStream("/Users/Shared/薛之谦-一半.mp3"));
32             //使用byte[]创建Blob
33             blob = new SerialBlob(bytes);
34             //设置参数
35             pstmt.setBlob(3,blob);
36             pstmt.executeUpdate();
37         } catch (SQLException e) {
38             e.printStackTrace();
39         } catch (IOException e) {
40             e.printStackTrace();
41         } finally {
42             try {
43                 if (pstmt != null) pstmt.close();
44                 if (con != null) con.close();
45             } catch (SQLException e) {
46                 e.printStackTrace();
47             }
48         }
49     }
50     /**
51      * 从数据库中读取map3
52      */
53     @Test
54     public void fun2() {
55         Connection con = null;
56         PreparedStatement pstmt = null;
57         ResultSet rs = null;
58         Blob blob;
59         //1、得到连接
60         try {
61             con = JdbcUtils.getConnection();
62             //2、给出select语句模板,创建pstmt
63             String sql = "SELECT * FROM tab_bin";
64             pstmt = con.prepareStatement(sql);
65             //3、pstmt执行查询,得到ResultSet
66             rs = pstmt.executeQuery();
67             //获取名为DATA列的数据
68             if (rs.next()) {
69                 blob = rs.getBlob("DATA");
70                 //把Blob变成硬盘上的文件
71                     /*
72                     * 1、通过Blob得到输入流对象
73                     * 2、自己创建输出流对象
74                     * 3、把输入流的数据写到输出流中
75                     * */
76                 InputStream in = blob.getBinaryStream();
77                 OutputStream out = new FileOutputStream("/Users/Mac/Downloads/薛之谦-一半2.mp3");
78                 IOUtils.copy(in, out);
79             }
80         } catch (SQLException e) {
81             e.printStackTrace();
82         } catch (IOException e) {
83             e.printStackTrace();
84         } finally {
85             try {
86                 if (rs != null) rs.close();
87                 if (pstmt != null) pstmt.close();
88                 if (con != null) con.close();
89             } catch (SQLException e) {
90                 e.printStackTrace();
91             }
92         }
93     }
94 }

当存储数据大于设定值时会报如下异常:

com.mysql.jdbc.PacketTooBigException: Packet for query is too large (4188642 > 1048576). You can change this value on the server by setting the max_allowed_packet' variable.

需要对mysql配置文件(Mac中 /etc/my.cnf)相应位置进行添加修改:

图片 1

保存关闭,重启MySQL服务器即可解决。

 

时间类型、大数据,jdbc入门 一、时间类型 数据库类型与Java中类型的对应关系: DATE-java.sql.Date:表示日期,只有年月日,...

本文由小鱼儿玄机30码发布于编程,转载请注明出处:开闭原则,然后通过统一的方式来获取配置的资

关键词: 小鱼儿玄机30码