2024年java三个基础框架

大家好，我是讯享网，很高兴认识大家。

Spring

Spring是一个开源的控制反转IOC(Inversion of Control)和面向切面(AOP)的容器框架。它的主要目的是简化企业开发，解决类与类之间强耦合的问题。（需要导包）

控制反转：就是应用本身不负责依赖对象（目标对象）的创建及维护，依赖对象的创建和维护由外部容器（spring）负责。这样控制就由应用转移到了外部容器，控制权的转移就是所谓的反转。

AOP:

spring核心jar包：beans(bean节点)、context(spring上下文节点)、core(spring核心功能)、expression(spring表达式)、logging(日志) 五个

spring核心配置文件：applicationContext.xml 也可以命名为bean.xml ，配置文件第一步要先到官网(可在下载的包里找到index.html)复制约束(模板)，注意要对应版本。

实例化容器（创建容器对象）方法一：ApplicationContext ctx = new ClassPathXMLApplication("applicationContext.xml")参数可是文件名也可是xml的路径

一般情况下都用方法一。方法二：Resource resource = new ClassPathResource("xml的路径"); 创建bean工厂的java三个基础框架方式，需要两步

BeanFactory factory = new XmlBeanFactory(resource);

Spring框架环境搭建（xml配置文件要与springmvc配置文件区分）

（范例获取已实例化的bean）用工厂类获取的方法为多此一举不建议使用

方法一

-->需要到官网下载jar包

-->需要创建xml配置文件(配置文件模板可到官网取)名字可任意取

-->在测试类下实例化Spring容器，在类路径下寻找配置文件来实例化Spring容器(在scope为默认值的情况下实例化Spring时，即所有<bean>元素下的类都实例化了) eg: ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");参数xml文件如果放在src下就可直接写xml文件名，如果放在包下，就的写当前文件路径，spring可以指定多个配置文件，当有多个配置文件时可以通过(new Sting[]{"beans.xml"})来传入。

ClassPathXMLApplication类的构造方法里调用了一个获取xml里所有bean类并将所有bean实例化得到对象并存进map的方法（）（也可以说在xml里被<bean>配置的类都被实例化了），而getBean方法里调用了map对象，通过id这个key获取存在里面的对象

-->创建bean类，必须实现接口

-->在配置文件里配置，管理bean类，<bean>元素用于配置交给Spring管理的bean类

-->在测试类下，用getBean方法通过bean在配置文件的id名，获取bean的对象，用该bean的接口声明(接住),要强转，getBean返回Object

-->通过对象使用该bean方法

方法二使用静态工厂方法实例化

建立工厂类(自己定义）--> 在该类创建静态(static)的工厂方法，该方法里new bean对象并返回bean的对象

配置文件中配置静态工厂的类和方面，如：<bean id="xxx" class="静态工厂类的路径" factory-method="工厂方法名"/>

在测试类同样通过ctx.getBean("xxx")获取bean对象

方法三使用实例化工厂示例化

建立工厂类(自己定义) --> 在该类创建工厂方法，该方法里new bean对象并返回bean的对象

配置工厂类<bean id="xxx" class="工厂类路径"/>实例化工厂类

在测试类同样通过ctx.getBean("xxx2")获取bean对象

三种方法对比，方法三比方法二少了静态，在xml里配置要多写一个bean先实例化工厂类，再可调用方法，而方法二因为是静态，可直接用类调用方法；方法二比方法一，多了个在里面创建bean对象的工厂(静态)类,而方法一可直接用bean类，通过spring获取对象。所有通常使用方法一。

在spring的xml文件给对象赋值，如果对象是通过构造方法传参来赋值的在xml<bean>里就用使用<constructor-arg>，如果对象是通过set方法赋值的就在<bean>里使用<property>来赋值，

Spring的配置文件xml的标签：

（属性后面都是接=号）

<bean>用于配置交给Spring管理的bean类。

属性id为bean取名称，id名称在Spring容器中是唯一的，当要获取该bean时通过此id获取，id是受xml解释器检验的不能有特殊字符，当要用到特殊字符取名时要用name属性，但符合条件是优先用id；

属性class指定交给Spring管理的bean类，写上类的路径。

属性scope，当属性值为默认值"singleton"时为单例（即在getBean取对象时，同一个bean无论取多少次都为同一个对象，hashCode都是相同的），一般用在service、dao、工具类的对象上，并且在用此属性值时，xml的会在容器创建时全部创建好；当属性值为"prototype"时为多例（即同一个bean每用getBean取一次对象，都是不同的对象），一般用在Action类的对象上，并且在此属性值，xml上的bean只有在获取对象时，才会去创建，即用一个创建一个。

属性lazy-init，（此属性只在scope="singleton"时使用，即只对单例有效）当属性值为默认值"false"时，保持原有的在容器创建时创建bean对象，当属性值为"true"时，为在获取bean对象时才创建bean对象。

属性init-method为只对bean对象创建之后，立刻执行的方法（只比对象的构造方法晚执行），后面接该bean里的任意一方法名。

属性destroy-method为指定在对象销毁前一刻执行的方法，即容器对象调用destroy销毁方法时执行（容器得用实现类）。

属性p: p名称空间，可直接为set方法赋值，可代替(优化)<property>标签，赋对象值如set方法为setDao则写法为: p:dao-ref="dao在bean的id"，赋基础变量值如int，Sting等，当set写法为setName时写法为：p:name="张三";

属性autowire="byName" 此属性和属性值表示该bean可自动根据自己有的属性名，在loc容器(xml文件)里找到与属性同名的bean并赋进去，此标签的作用也是（替代）优化了<property>;另外在xml约束后面加上 default-autowire="byName"可把xml下全部bean都设为自动注入.

<constructor-arg>此标签一般用在<bean>标签内（被包含在<bean>内），用于给有有参构造器的bean设置参数（一个参数只能使用一个标签）。

属性type根据构造器参数，指定参数的类型，在类型为基础类型时直接写，在不是基础类型时例如String就得把给类型的路径名写上java.lang.String.

属性value为参数指定值.

属性index为该参数的顺序，从0开始

属性ref 指定在该spring容器中，和参数同类型的bean作为该参数，写法为ref="与参数同类型的bean的id名"

<property>此标签用于<bean>标签内（被包含在<bean>内），用于可在xml文件内就调用属性的set方法给bean的属性设值。（一个set方法只能用一个标签）

属性name一般为set方法的方法名。但一般的写法要注意，例如：set方法为setName，要这样写name="name";去掉set把大写该小写

属性value为指定set方法的属性值

属性ref 指定在该spring容器中，和参数同类型的bean作为该参数，写法为ref="与参数同类型的bean的id名"

【注解可以和xml里的<bean>一起使用】

spring的注解（注解可代替xml上的<bean>，把类加入到xml等待被创建对象后加入到ioc容器）要引入aop包

1、使用注解要先在配置文件约束的部分引入context名称空间，一般约束都有；

2、开启注解扫描，要在xml配置文件加入标签<context:component-scan base-package="写所要扫描的包的路径"；

3、可以在被扫描的包下的类使用注解了

@Component("xxx") 此注解表示将注解下面的类的对象加入ioc容器，xxx表示自定义的对象名，一般xxx的写法为，跟类名相同但首字母小写，例如类为UserDao则写@Component("userDao")即相当于类为<bean id="userDao" class="...">

@Component 此注解是简化的写法，即会把注解下面的类的对象加入到IOC容器，并且会自动生成id，此id名为类名，首字母小写

@Component 可以用@Repository @Service @Controller 来代替，即可明确显示个层，亦可以等同于@Component

@Resource(name="值(对象)的名称") 此注解是为注解下面的属性赋值,根据名称在IOC查找注入的对象，如果值为已是IOC容器的对象，就填写此对象的id。

@Resource 此注解是也为注解下面的属性赋值，但是根据类型在IOC查找注入的对象，为属性所赋的值（对象）是根据属性类型在IOC找到相应的对象，【用此注解要确保该类型只有一个对象】

真实角色==目标对象目标对象方法==目标方法==核心业务方法==业务代码关注点代码==附加功能==关注点

在spring的AOP编程中

如果目标对象有实现接口，用动态代理；如果目标对象没有实现接口用Cglib子类代理

代理模式

组成：

抽象角色：通过接口或抽象类声明真实角色实现的业务方法。

真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。（实现接口，处理主要业务逻辑）

代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。（也实现接口，同时调用真实角色，添加附加处理，最后使用代理角色）

代理模式不能代理套代理，装饰模式可以多成套

（静态代理）代理对象要实现和目标对象一样的接口，通过在代理对象注入目标对象，并在同名的方法上调用目标对象的方法，可以在不修改目标对象的前提下，对目标对象进行扩展。缺点：一旦为接口增加方法，目标对象和代理对象都要修改，而且如果目标类接口不一样代理类也要不一样

（动态代理）需要目标对象有实现接口，必须创建一个代理工厂类，可以注入不同类型的目标对象，在代理工厂中添加附加处理，从而从代理工厂生成代理对象。优点：可以不用和目标对象实现同一接口，可以代理不同类型的对象。一般代理工厂有固定写法：

public class ProxyFactory {

private Object obj;

public ProxyFactory(Object obj){

this.obj = obj;

}

public Object getProxyInstance(){ //实例化工厂后，必须调用此方法才可以生产代理对象

return Proxy.newProxyInstance(obj.getClass().getClassLoader(),

obj.getClass().getInterfaces(),

new InvocationHandler() {

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

System.out.println("action");

Object returnValue = method.invoke(obj, args);

System.out.println("end");

// TODO Auto-generated method stub

return null;

}

});

}

（cglib子类代理）也是属于动态代理跟动态代理写法类似，但目标子类可以不用实现接口，cglib实际上是利用目标对象作为作为父类，继承目标对象，重写目标对象方法来实现代理。

cglib需要导入cglib包，但spring核心包已包含了cglib包的功能，所以不用特别引入；cglib子类代理也要跟动态代理那样创建代理工厂，但代理工厂获取的代理对象同时也是目标对象的子类。Cglib代理工厂类写法基本固定如下：

public class CglibProxy implements MethodInterceptor{

private Object obj;

public CglibProxy(Object obj){

this.obj = obj;

}

public Object getProxyInstance(){

Enhancer enha = new Enhancer(); // 工具类

enha.setSuperclass(obj.getClass()); //设置父类

enha.setCallback(this);//设置回调函数

return enha.create(); //创建子类（代理对象）

}

@Override

public Object intercept(Object object, Method method, Object[] arg, MethodProxy mp) throws Throwable {

// TODO Auto-generated method stub

System.out.println("action.....");

Object returnvalue = method.invoke(obj, arg);

System.out.println("end.....");

return returnvalue;

}

AOP面向切面的编程（aop着重点于切面，利用代理模式，把代理工厂中的附件功能抽取为一个切面类，编程重点面向切面类）

AOP原理：

AOP可以实现“业务代码”与“关注点代码”分离；“业务代码”一般即指相当于代理中的目标对象中的方法，而“关注点代码”即相当于附加的功能内容。一般在AOP中“关注点代码”自己写在一个类上。从而这样关注点代码写一次就好，开发者只需关注核心的业务，运行时可利用代理模式中代理工厂把“业务代码”和“关注点代码”合成。

AOP利用注解方式简化完成分离（不用写代理工厂类了）：

关注点：重复的代码，即许多核心业务都要用到的附加功能；

切面：为这些重复的代码创建的一个类，即叫“切面”，面向切面就是把一段代码中重要的可能要经常修改的业务方法和不须要经常更新的重复利用的代码拆分，把不须要经常更新的抽取出来写到一个类（切面）中，再到运用核心业务方法时动态植入

切入点：切面植入哪个核心业务方法（目标方法），即核心业务方法要经常更新所以可以有多个，切面选择（拦截）哪个业务方法植入（切入）即切入点。

利用注解的方式步骤：

导入AOPjar包：spring-aop-4.2.5.RELEASE.jar、aopalliance-1.0.jar、aspectjweaver-1.8.8.jar；

xml配置文件约束中要引入aop的名称空间

在xml中开启aop注解方式<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

创建切面类，

@Aspect此注解标识此类为切面类

@Pointcut("execution(* com.homework.user.action.ActionImp.*(..))")指定切入点表达式，写在方法上，注解下的方法的方法名即代表了此拦截的路径，可在后面的注解直接写方法名代表路径，方法可没内容；注解后面的括号为切入点表达式，指定拦截哪个类的哪个方法切入，上面举例ActionImp类的全部方法切入关注点，*表示全部方法，(..)表示任意参数，或无参数

例：@Pointcut下的方法为

public void pointcut(){

}

后面的注解可直接填pointcut()

@Before("pointcut()") 目标方法执行前执行的关注点代码（写在一个方法上）的注解（目标方法出现异常时仍执行）

@After("pointcut()") 目标方法执行后执行的关注点代码（写在一个方法上）的注解（目标方法出现异常时仍执行）

@AfterReturning("pointcut()") 写在方法上，表示调用目标方法结束后执行（目标方法出现异常不执行）

@AfterThrowing("pointcut()") 写在方法上，表示当目标方法执行异常时执行

@Around("pointcut()")写在方法上，表示环绕目标方法执行，相当于@Before+@After（目标方法出现异常不执行）

最后直接执行被拦截的核心业务方法（目标对象的方法），即可,关注点代码会自动植入到业务方法中。

注：目标对象有实现接口时，aop会自动选择动态代理，没有实现接口时，回自动选择Cglib子类代理。

AOP利用xml方式简化完成分离（不用写代理工厂类，不用写aop的注解）

同样要引入一样的jar包，和约束的名称空间，同时也要创建切面类（但切面类不用添加aop注解，除了ioc容器的注解）

在xml配置AOP，使用标签<aop:config>配置一个切面，使用<aop:aspect ref="切面对象的id">引用切面类的对象，<aop:before>目标方法执行前执行<aop:after>目标方法执行后执行

aop具体使用到的标签如下：

<aop:config>开始aop配置

<aop:pointcut expression="拦截哪些方法的路径" id="pt"/> 定义一个切入点表达式，使后面的标签可直接使用id，使用方便

<aop:aspect ref="切面对象的id"> 指定切面，写在<aop:config>标签内

<aop:before method="方法名" pointcut-ref="pt"/> 写在<aop:aspect>标签内，指定目标方法执行前执行的方法

<aop:after method="方法名" pointcut-ref="pt"/> 写在<aop:aspect>标签内，指定目标方法执行后执行的方法

切面内各种方法的调用的标签基本和注解类似

SpringMVC （笔记注释：handler==处理器==Controller）

使用SpringMVC框架搭建

-->> 首先要导入springmvc的所有jar包

-->> 配置前段控制器，在web.xml中配置前端控制器

<servlet-name>springmvc<servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> //此类即为前段控制器DispatcherServlet,可在springmvc的核心jar包中找到

在DispatcherServlet中里需要配置一个初始化参数，此参数即springmvc所需要加载的配置文件（此配置文件里配置处理器适配器，处理器映射器，视图解析器等），好让DispatcherServlet找到，并调用。DispatcherServlet配置初始化参数如下（放在Servlet标签内）：

<init-param>

<param-name>contextConfigLoction</param-name>

<param-value>classpath:springmvc.xml</param-value> //在src下创建springmvc.xml以配置处理器适配器、处理器映射器等

</init-param>

</servlet>

接着继续在web.xml下配置servlet-mapping，根据条件拦**问的web资源

<servlet-mapping>

<servlet-name>springmvc</servlet-name>

<url-pattern>*.action</url-pattern>

// url-patterm的配置方式有：*.action 即拦**问 .action结尾由DispatcherServlet进行解析

</servlet-mapping> / 所有访问的地址都由DispatcherServlet进行解析，但同时也会让静态页面也进入，所有一般不适用，但适用此方式可以实现RESTful风格的url

-->> 结合web.xml里的DispatcherServlet配置，需要在src下创建springmvc.xml配置文件，以配置处理器适配器，处理器映射器，视图解析器等。

-->> 找到springmvc.xml 配置文件的约束，并写进去

-->> 配置springmvc最主要目的是让框架能够执行handler，首先要配置处理器适配器，处理器映射器，视图解析器，配置不分先后顺序

-->> 配置处理器适配器：

<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/> //此类就是一个处理器适配器

//所有的处理器适配器都要实现HandlerAdapter接口，所以此类也实现了HandlerAdapter接口

//通过查看适配器的support的方法可以知道，handler应该实现哪个接口才能被该适配器所适配，而在SimpleControllerHandlerAdapter这个适配器中查看support可知道，handler必须实现Controller接口才能被适配（使用）

当handler实现Controller接口后要实现一个返回值为ModelAndView类型的方法，所以在方法内new一个ModelAndView的对象，以便返回，ModelAndView里的方法addObject("xxx",xxx);可以存对象，根据ModelAndView指定的jsp视图，可到了jsp页面中再从对象中取数据，做到了的把数据传到页面（第一个xxx表示到了jsp页面中代表对象的名字，第二个xxx表示在当前方法里要存的对象），相当于request的setAttribute，

//指定视图，使用ModelAndView的方法setViewName("参数为要转发到的jsp页面的url")

处理器适配器方法二：

//此适配器要求handler实现HttpRequestHandler接口才能被适配器所适配

-->> 配置处理器映射器

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" /> //根据此类的字面意思理解，handler的bean的名字和url相同才能映射到handler，所有在配置handler时要指定beanname（要指定哪个url找哪个handler处理就bean名称和url相同）

-->> 配置handler的bean：<bean name="/xxx.action" class"handler的路径" />

配置处理器映射器的方法二（handler对应的url都写在处理器映射器的bean里）：

<props>

<prop key="/xxx.action">handler</prop>

<prop key="/xxx.action">这里写配置好handler的bean的id</prop> //可以写多个不一样的映射关系

</props>

</property>

</bean>

-->> 配置视图解析器

<bean class="org.springramework.web.servlet.view.InternalResourceViewResolver">；

<property name="prefix" value="/xxx/xxx" /> 配置的前缀和后缀在ModelAndView指定视图时，都不用写以配好的前后缀

/

</bean>

以上为非注解的配置方式

在不配置映射器和适配器也可以使用，因为不配置时默认加载springmvc核心包下的DispatcherServlet.properties配置文件，但一般都自己配置

一般情况下推荐使用注解的配置方式（如下）：

-->>配置注解映射器

-->>配置注解适配器

-->>注解映射器和注解适配器合二为一的配置，此配置可代替以上两个，开发中一般使用此配置，因为功能更强大

<mvc:annotation-driven></mvc:annotation-driven> //推荐使用

-->>使用注解：

在handler类上标记注解@Controller

在handler方法名上标记注解@RequestMapping("/xxx") xxx为需要自定义映射的路径，后缀名.action可写可不写

同时还要把注解的handler类加入IOC容器即配置bean，可在springmvc单个配置，也可用注解扫描该类或该报，一般都用扫描

mybatis

需要导入mybatis核心包和数据库驱动包；创建表和实体的映射配置文件（相当于Dao的功能）；src下创建mybatis的xml文件

表和实体的映射配置文件要加入相关的约束，加完约束后开始配置：

<mapper namespace="xxx"> //映射区域名称空间

<resultMap type="" id=""> //resultMap表示映射实体与表；type属性内写实体的全路径名；id为此映射取名称

<id property="" column=""/> //id主键映射标签；property属性实体的属性名；column属性表的字段名

<result property="" column=""/> //除id主键映射外，其他属性和字段之间的映射

.....

</resultMap>

//insert标签声明这会是一个插入的sql语句；id属性为此操作名称建议跟dao中的对应方法名一样；parameterType属性为类似dao中增删改查方法中要插入的参数的类型，即sql要用//到的参数类型，参数如果是实体类的话要使用全路径，如果是int、String等就直接写int、String等，sql语句中参数名要跟实体属性名一样或基础类型的话要跟dao中参数变量名一样

//在执行有返回值的查询时，resulType属性为返回参数的类型

insert into taobao(name,price,description,image) values(#{name},#{price},#{description},#{image})

</insert>

<select id="" parameterType="" resultMap=""> //如果表中字段名跟属性名不一样时，返回值类型要用resultMap的id名，在有多个基础类型的参数时可把他//们放进map中取

select name，age from students where limit #{map里参数的键}，#{map里参数的键}

</mapper>

src下mybatis配置文件的编写：

<environments default=""> //默认链接环境信息，在此标签内可以配置多个environment链接环境信息，如MySQL或oracle或同一数据库不同的配置，可灵活选择一个使用，在default属性中写入environment的id即可。

<environment id="mysql_developer"> //链接环境信息，任意取一名字

<transactionManager type="jdbc"/> //mybatis使用的是jdbc的事务管理方式

<dataSource type="pooled"> //mybatis使用链接池方式获取链接

<property name="driver" value=""/> //配置链接池参数，必需写在dataSource标签内

</dataSource>

</environment>

<mappers> //让mybatis可以找到此配置文件，mapper可以写多个

</mappers>

mybatis配置文件优化写法：

可把链接的参数写到一个后缀为properties的配置文件，例：mysql.driver=com.mysql.jdbc.Driver

再回到mybatis配置文件在configuration标签内增加<properties resource="xxx.properties"/>后，再在dataSource标签的property配置链接池时，value可以用value="${mysql.driver}"变量来取代

之后只要在xxx.properties里改变配置就可以了

建立MabatisUtil类，使之加载mybatis.xml配置文件，mybatis.xml又去加载表与实体的映射文件

并且在MybatisUtil类内创建一个重量级SessionFactory

通过SessionFactory获取轻量级Session

mybatis的SqlSession相当与mybatis的会话链接成功，可以从SqlSession内获取mybatis许多相关功能

public class MybatisUtil{

private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>();

private static SqlSessionFactory sqlSessionFactory;

static{

Reader reader = Resources.getResourceAsReader("mybatis.xml");

sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); //会话工厂需要通过mybatis创建

}

public static SqlSession getSession(){ //获取sqlSession

SqlSession sqlSession = threadLocal.get(); //查看threadLocal中当前线程有没有绑定有sqlSession

if(sqlSession == null){ //如果没有绑定，这也是第一次时要执行的

sqlSession = sqlSessionFactory.openSession();

}

return sqlSession;

}

public static void colseSqlSession(){

SqlSession sqlSession = threadLocal.get();

if(sqlSession!=null){

sqlSession.close(); //关闭sqlSession

threadLocal.remove(); //分开sqlSession与线程，目的让垃圾回收尽快回收

}

在对应的dao方法中调用MybatisUtil工具类获取sqlSession对象，从对象中调用增删改查方法，其增删改查的方法的参数对应为表和实体映射文件的sql语句的id名称，例：

sqlSession.insert("映射区域空间名称 . insert的id")

有参数时可重载此方法：sqlSession.insert("映射区域空间名称 . insert的id"，放入参数可以是实体或基础类型)；当放入参数是多个时可以用map存放参数，如有两个int时，

Map<String,Object> map = new LinkedHashMap<String Object>;

map.put("xxx",xxx);

map.put("XXX",XXX);

sqlSession.selectList("映射区域空间名称 . select标签的id",map);

一般都要加入事务，开始事务默认开启，但提交事务一定要写sqlSession.commit();在catch里回滚事务，最后关闭sqlSession

mybatis动态sql查询（即在一条sql语句中，动态地改变查询条件，该条件类型可有可无，条件类型里的参数可改变）

同样先把条件参数加入到map

Map<String Object> map = new LinkedHashMap<String Object>();

map.put("mid",id);

map.put("mname",name);

然后在表和实体的映射文件中编写：

select id,name from users

<where> //相当于sql中的where

<if test="mid != null"> //如果如果事件 Map中的mid不为null值，则执行下面sql语句，如果为null就略过此执行下一条,即没有id类型的条件

and id = #{mid}

and name = #{mname}

</where>

动态更改：

update users

<set>

<if test="mname != null"> //如果事件 Map中的 mname不等于null值，则执行下面sql语句，空则跳过略过此语句

name=#{mname}

</if>

age=#{mage}

</if>

</set>

where id=#{mid}

</update>

动态删除（即通过一条sql语句根据一些id删除一些行）

静态写法：delete from users where id in(1,2,3,4); 删除id为1234的行

动态即根据用户输入id来选择删除哪些行（由于用户可输入多个的id，不知其长度，所以用数组来存参数）

<delete id="" > //不用写参数类型，因为下面迭代时会写

delete from user where id in

// foreach 标签迭代数组元素，Collection表示迭代的类型，open表示开始的符号，close表示结束的符号，separator表示元素间的分隔符，item表示迭代的数组

<foreach collection="array" open="(" close=")" separator="," item="array" //item=的是对象，建议名字和传进的数组参数一样

#{array}

</foreach>

</delete>

动态增加（即在每一行中，根据用户选择在哪一字段下插入信息）

//定义sql片段

//<trim>标签为修剪标签，属性suffixOverrides表示指定最后一个字符去掉，这里指去掉最后一个逗号

<if test="name != null"> //name为实体类里的name

table_name,

</if>

<if test="age != null"> //age为实体类里的age

table_age,

</if>

</trim>

</sql>

#{test},

</if>

#{age},

</if>

</trim>

</sql>

//<include refid="key">和<include refid="value">表示要引用已定义的sql片段

insert into user(<include refid="key"/>) value(include refid="value"/)

</insert>

mybatis中多表查询

一对一

mybatis利用接口（mapper代理开发方法）只需写接口，不用写dao实现类

程序员除了需要配置原来的xml映射文件，还有编写mapper接口（相当于原来的Dao接口），需要遵循一些开发规范，mybatis可以自动生成mapper接口实现类代理对象

编写规范：

1、在mapper.xml中namespace等于mapper接口地址

2、mapper.java（mapper接口）的方法名和mapper.xml中各sql语句操作的id相同

3、mapper.java(mapper接口）中的方法输入参数类型和mapper.xml中的对应sql语句操作的输入参数类型一致

4、mapper.java(mapper接口)中方法的返回值类型和mapper.xml中的对应sql语句操作的resultType指定的类型一致

注：因为在系统框架中，dao层的代码是让业务层公用的，mapper接口方法参数最好只有一个，否则可以使用包装类型的pojo满足不同的业务方法需求，只用map也可以

VO指视图层的对象

PO指持久层的对象

POJO表示自定义的JavaBean

概念模型

项目初期就要通过需求把概念模型固定下来，最终概念模型要转换成对象模型和关系模型

对象模型：概念模型在Java中相当于领域对象domain，实体（javaBean）；

关系模型：在数据库中就是表

概念模型里存在三种关系：

一对多：例如一个国家有多个省份，一个省份只属于一个国家

一对一：例如夫妻之间

多对对：例如老师有多个学生，学生有多个老师

在对象模型中这些关系都是双向关联的，即在各实体或类中都要写上对方，在国家实体中要写上省份属性（用list），省份实体中要写上国家属性

在关系模型中数据库表上，国家有自己主键就可以了，而从表省份就必须在外键写上国家主键的值

spring解决类与类之间强耦合的问题

控制反转，比如需要对象，不须要自己创建，ioc会给

spring是开源的框架，需要用到jar包，

springMVC拦截器

preHandle在Action之前执行，如果返回true，则调用相应的action或下面的拦截器，如果返回false，则终止执行

afterCompletion在view渲染之后执行，一般用于最要的资源清理工作

postHandle在View解析之前，在Action执行之后执行

一般服务器响应到浏览器

请求响应式模式

无状态

应用层协议

TCP

浏览器地址回车是get请求

1xx 提示信息

2xx 成功信息

3xx 客户端重定向

协议://域名:端口/应用访问路径/servelet的映射路径

servelt工作模式：

单实例多线程

没有怕诶之load-on-startup（在容器启动时初始化）情况下，第一次被访问的时候进行servlet对象实例化，由servlet容器调用init方法进行初始化，每次请求调用service方法进行请求的处理，当容器关闭时调用destroy方法释放资源

一个servelt类，可以置多个servelt实例

一个servelt实例，可以配置多个映射地址

Dao 持久层（数据操作；增删改查）

M 业务逻辑层（业务逻辑处理）

V 显示层（jsp，freemarket，js）

C 控制层（servlet）

一个servlet容器可以部署多个应用（servletContext）

一个应用（servletContext）对应多个servlet

命名规则：

类名首字母必须大写

方法名和属性名首字母小写

由多个单词组成的类名或方法名必须采用驼峰标识

eg：类名StudentAdmin 方法名或属性名studentName

web.xml 中<context-param> 初始化参数，所有Servlet/jsp可用

<param-name>xxx</param-name>

<param-value>yyy</param-value>

</context-param>

可以在jsp中用el表达式${initParam.xxx}在页面上显示yyy

利用反射获取properties配置文件的流的方法：

InputStream in = 本类类名.class.getClassLoader().getResourceAsStream("xxx.properties"); xxx为properties配置文件名，在src就直接下写名字

properties pro = new properties();

pro.load(in);

2024年java三个基础框架

相关推荐