Spring

SSH框架中Struts2:是基于Web层，Hibernate：是基于持久化的，Spring:业务层，管理bean，它是一个容器，List,map， Set这里的内容，是适合已经学过了Spring的人供复习参考的.....
Spring框架的优点： 
  1. Spring是分层的架构，你可以选择使用你需要的层而不用管不需要的部分
  2. Spring是POJO编程，POJO编程使得可持续构建和可测试能力提高
  3. 依赖注入和IoC使得JDBC，Hibernate操作简单化
  4. Spring是开源的免费的
  5. Spring使得对象管理集中化合简单化 

在爽一把前，先要弄懂Spring容器中装的bean--生命周期，如下图，很好的说明了bean的声明周期。

在说Spring的时候，我们先爽一把吧
   1，创建java项目
   2，加入Spring开发相关的jar包
   3，创建业务类
      /**GreetingService*/
       public class GreetingService{
           private String greeting;
           private String greeting2;   //相应的get、set方法
         
           /**buyService*/
           private ByeService bs;
           public void syaGreeting(){
               bs.syeBye();
           }
       }

    /**BuyService*/
      public class ByeService{
          private  String bye;
          public String getBye() {
   return bye;
  }
       public void setBye(String bye) {
   this.bye = bye;
  }
 public void  sayBye(){
                                System.out.println(bye);
         }           
      }
   配置Spring文件
      <?xml version="1.0"?>
<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-2.5.xsd">
      <bean id="greetingService" class="...GreetingService">
                             <property name="greeting">
 <value>hello world</value>
     </property>
              <property name="greeting2">
<value>tom</value>
     </property>
     <property name="bs" ref="byeService" />
      </bean>
                      <bean id="byeService" class="....ByeService">
                            <property name="bye">
        <value>later</value>
    </property>
                      </bean>

  创建app
     ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
     GreetingService gs = (GreetingService)ac.getBean("greetingService");
     gs.sayGreeting();
     gs.sayGreeting2();
     
     ByeService bs = (ByeService) ac.getBean("byeService");
     bs.sayBye();

spring:
ioc:inverse of control,反转控制.获得依赖对象的方式被反转了.
1.new.(spring负责对象实例化)
2.组装对象的出发点是反的.
DI:dependency injection,依赖注入.
aop:aspect oriented program,面向方面编程.

oop:面向对象编程.
BeanFactory:实例化bf时，不会实例化任何bean,只有在getBean的时候才会实例化相关的Bean,这样做能够节省资源
ApplicationContext:在实例ac的时候，是会实例单例的bean(在结合struts的时候，管理action，action是原型的，                    所以，在实例化的时候是不会实体化的)
set注入的缺点是无法清晰表达哪些属性是必须的，哪些是可选
    的，构造注入的优势是通过构造强制依赖关系，不可能实例化不
    完全的或无法使用的bean。
自动装配:
        <bean id="foo" class="...Foo" autowire="autowire type">
1.byName:按照名称自动装配,寻找和bean的属性名相一致的bean的id.(bean必须有空的构造,通过set方法注入)
2.byType:按照属性的类型来自动装配,如果找到多个,抛异常.(bean必须有空的构造,通过set方法注入)
3.constructor:按照构造函数参数的类型自动装配,如果找不到或者找多个,都抛异常.
4.autodetact:自动检测,在(2)和(3)之间选择一个.
5.no.
6.default,跟<beans default-autowire属性>保持一致.


分散配置:
把需要在上下文硬编码的属性拿到外部的属性文件中定义,让上下文从外部文件提取值.


自定义编辑器:
将字符串转换成相应的对象,

aop:面向方面编程.不改变源代码,还为类增加新的功能.(代理)
切面:实现的交叉功能.
通知:切面的实际实现.
连接点:应用程序执行过程期间,可以插入切面的地点.
切入点:真正的将通知应用到目标程序中的地点,一定是连接点.切入点是连接点的子集.
引入:为类增加新的属性和方法.
目标对象:被通知的对象.
代理:把通知应用到目标对象以后,产生新的对象,该对象就称为代理对象.
织入:创建代理对象过程.
编译期织入:.java  --> .class,需要特殊的编译器.
类装载期织入:将java字节码载入到jvm时,将通知织入.需要特殊的classloader.
运行期(runtime):
cglib:
aop alliance:aop联盟.

spring aop编程:
1.aop alliance.jar(已经集成在spring.jar中) + cglib.
${spring解压目录}/lib/cglib/*.jar
2.加入aspectj类库
${{spring解压目录}/lib/aspectj/*.jar(aspectjrt.jar + aspectjweaver.jar)
3.创建接口和实现类
public interface WelcomeService {
public void sayName();
}
/**
* 目标类
*/
public class WelcomeServiceImpl implements WelcomeService {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}

public void sayName() {
System.out.println(name);
}
}
4.创建前置通知.
/**
* 前置通知(方法前通知)
*/
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {
public void before(Method method, Object[] args, Object target)
throws Throwable {
System.out.println("hello world");
}
}
5.配置文件.
<?xml version="1.0"?>
<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-2.5.xsd">
<!-- 前置通知(方法前通知) -->
<bean id="myMethodBeforeAdvice" class="....MyMethodBeforeAdvice" />
<!-- 目标对象 -->
<bean id="welcomeServiceTarget" class="......WelcomeServiceImpl">
<property name="name" value="tom" />
</bean>
<!-- 代理对象 -->
<bean id="welcomeService"                                   class="org.springframework.aop.framework.ProxyFactoryBean">
<!-- 代理接口集 -->
<property name="proxyInterfaces">
<list>
<value>.....WelcomeService</value>
</list>
</property>
<!-- 拦截器名集 -->
<property name="interceptorNames">
<list>
<value>myMethodBeforeAdvice</value>
</list>
</property>
<!-- 指定目标对象 -->
<property name="target" ref="welcomeServiceTarget" />
</bean>
</beans>
6.App
ApplicationContext ac = new ClassPathXmlApplicationContext(
"...aop.xml");
WelcomeService ws = (WelcomeService) ac.getBean("welcomeServiceTarget");
ws.sayName();

public interface Pointcut{
ClassFilter getClassFilter();
MethodMatcher getMethodMatcher();
}
Pointcut:切入点
Advice:通知
Advisor:切入点通知,组合体,既包含通知又包含切入点.对原来的通知的包装,增加定义切入点功能
PointcutAdvisor{
Pointcut getPointcut();
Advice getAdvice();
}

引入通知:
1.定义引入通知.
Dao:data access object.数据(数据库的表数据)访问对象.
dto:data transfer object,数据传输对象. struts1(actionform jsp --> action)
集成dao.
1.引入数据源类库
${spring解压目录}/lib/c3p0/*.jar
c3p0-0.9.1.2.jar
2.配置spring配置文件,链接数据源
insert:
conn = ds.getConn
conn.setAutocommit(false);
String sql = "insert into customers(name,age) values(?,?)"  ;
ppst = conn.preparedStatement(sql)
ppst.setString(1,"tom");
//...
ppst.executeUpdate();
conn.commit();
ppst.close();
conn.close();

update:
conn = ds.getConn
conn.setAutocommit(false);
String sql = "update customers set name = ?,age=? where id= ?"  ;
ppst = conn.preparedStatement(sql)
ppst.setString(1,"tom");
//...
ppst.executeUpdate();
conn.commit();
pst.close();
conn.close();


//select
conn = ds.getConn
String sql = "select * from customers"  ;
ppst = conn.preparedStatement(sql)
ppst.setString(1,"tom");
//...
ppst.executeUpdate();
conn.commit();
ppst.close();
conn.close();

src/hibernate.cfg.xml
connection.driverclass
connection.url
user 
password
hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
hibernate.show_sql=true
hibernate.hbm2ddl.auto=create|update|drop|create_drop
hibernate:
Configuration conf = new Configuration();
conf.configure();
//缓存:预先生成的sql语句和映射元数据.  二级缓存:缓存插件,
SessionFactory sf = conf.buildSessionFactory();
Session s = sf.openSession();
Transaction tx = s.beginTx();
for(){
s.save(c);
}
s.save(c);
tx.commit();
s.close();

<bean id="ws" class="xxx.WelcomeServiceImpl" />
WelcomeService ws = ac.getBean("ws");
MyFB implements FactroyBean{
  getObject(){
return new Customer();
  }
}
<bean id="aa" class="...MyFB" />
Customer c = ac.getBean("aa");
spring整合hibernate:
1.引入hibernate类库.
antlr-2.7.6.jar
commons-collections-3.1.jar
dom4j-1.6.1.jar
hibernate3.jar
javassist-3.9.0.GA.jar
jta-1.1.jar
log4j-1.2.15.jar
slf4j-api-1.5.8.jar
slf4j-log4j12-1.5.0.jar
2.创建实体类的映射文件.
Customer.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="....Customer" table="customers" lazy="false">
<id name="id" column="id" type="integer">
<generator class="identity" />
</id>
<property name="name" column="name" type="string" />
<property name="age" column="age" type="integer" />
</class>
</hibernate-mapping>
3.spring:
connection.commit()|rollback
transaction.commit()|rollback.
事务:
a:atomic,原子性.
c:isolation,
i
d
事务管理:
1.编程式,硬编码方式.
2.声明式,
事务属性:
1.传播行为:事务的传递
2.隔离级别:控制并发程度的.
脏读:读未提交.
不可重复读:读不回去.
幻读:读多了.
ansi sql:
1:读未提交.
2:读已提交.
4:可以重复读.
8:串行化.

3.只读:优化.
4.超时:释放资源.
5.回滚规则:
把struts的action交给spring管理
    把action交给spring管理,并同时利用spring的DI功能完成依赖关系的装配.
public class xxxAction extends Action {
  public ActionForward execute(…){
    ….
  }
  private XxxService xxxService ;
  private getXXX() setXXX();//注入依赖
}
在spring上下文中,作为普通bean配置action,但action的不能用id,只能用name,
因为需要struts-config.xml文件中action的path一致.
bean.xml
<bean name="/loginAction" class="..LoginAction">
  <property name="xxxService" ref="xxxService" />
</bean>
注册代在struts-config.xml文件中需要配置请求处理器,负责到spring容器中寻找对应的action实例.
struts-config.xml
<controller processorClass="...DelegatingRequestProcessor" />
action的type属性可以去掉.
<action path="/loginAction"
            name="xxx"
            scope="request"
            validate="false|true" />
注:如果原来使用了特定的请求处理器.则需要改换配置代理action.注释掉控制器.如下:
<action path name 
            type="..DelegationActonProxy">
<!--
  <controller processorClass="..." />
-->理请求处理器
本人喜欢在整合struts2，hibernate的时候用注解的方式，这样使得配置文件大小大大降低了

Logo
向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

avatar 云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

avatar 云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

avatar 云原生