精华内容
下载资源
问答
  • 2021-03-22 13:13:01

    一直不太理解什么是框架,框架是jquery和javascript之间的这种关系吗?jsp有.

    可以这么说了,struts1,struts2,jsf 是用于结合前台展现的java框架

    Structs hibernate spring Struts Struts是一个基于Sun J2EE平台的MVC框架,主要是采用Servlet和JSP技术来实现的。Struts框架可分为以下四个主要部分,其中三个就和.

    java框架实在是太多了,网上一抄一大段,根本就了解不到什么。我还是以我的经验来说一下j2ee的框架。1.首先力推struts2框架,这是最经典的框架(可以说没有“之一.

    servlet是后台处理程序,负责接收客户端发送的信息,处理并返回相应的信息。jsp在现在的环境下,作用就如同一个显示器+键盘+鼠标,负责显示、输入数据。Java Web.

    JSP有哪些框架,流行的是哪些?JSP的框架都是MVC的吗?

    JSP是网站开发技术 既不属于编程语言也不属于框架MVC属于一种设计结构,目的是使网站方便开发,维护管理,结构清晰。能够方便开发者实现这种设计结构的框架目.

    struts:MVC框架 视图:大量的struts标签。 控制器:自动收到视图传递的参数。页面跳转使用逻辑名! 模型:可以整合Hibernatespring:主要使用其Bean工厂!使用对象.

    jsp是用来编写java动态页面的,可以算是一门语言,其编写的页面最终编译成servlet执行,不好说什么框架,一般都说java的框架

    modle1 和2?要简洁明了还能解决问题,这是一道考试题···

    model1:jsp页面独自响应请求并将处理结果返回客户,这里里面使用了表达与内容的分离,其中数据存取都是由bean来完成的。model2: MVC标注模式,JSP用于view展示.

    jsp和struts不是一个概念:JSP是一种用java开发web(网页)程序时,在HTML页面嵌入的语言,类似asp,php等网页开发语言。structs是一种java开发框架,或者说是一种.

    有的框架还把JSP给完全抛弃了,一时半会还无法接受.. 大家来说说吧,用.

    当初Java诞生的目的就是要把程序设计的核心集中在解决问题上,而不是去操纵底层. 此外更注重可靠性、可维护性,这是其他语言的框架所不可超越的!Java 开源,众多.

    常用的MVC框架有JSP + servlet + javabean的模式。MVC模式的某种框架,它强制性的使应用程序的输入、处理和输出分开。使用MVC应用程序被分成三个核心部件:模.

    请问这幅图有没有用到框架,如果用到的话,怎样才能在页面下面用到框架?.

    jsp的编程是面对的是数据处理问题,具体框架是MVC模式的,而你的这个是网页模型,只是用的是dreamwerver等软件就可以实现你的视图,但你要想对里面的数据进行处.

    这是不是jsp专有的框架,属于HTML标签,frameset 是一个frame容器,里面放frame,frameset可以嵌套frameset 以下将一个页面分三列,宽度分别是25%,50%,25%,三列.

    Spring Framework 【Java开源 J2EE框架】 Spring 是一个解决了许多在J2EE开发中常见的问题的强大框架。 Spring提供了管理业务对象的一致方法并且鼓励了注入对接口.

    是用include还是frameset,还有人建议用css+div应该怎么做?最好有详细的。

    用frameset把~他可以指定左边菜单的连接跳到中间去! 比include要好!你把代码复制过去把里面的jsp路径改成你自己的!试试! <html> <head> </head> &lt.

    如果是为了开发速度快,就用java和jsp就行,jsp中嵌入大量的java代码 如果是好维护,就用mvc模式,高级点的就用struts框架 jsp的页面最好用ajax和javascript,这样用户.

    学习使用框架必须具备一定功力的java知识、xml基础概念等,这需要积累使用经验,这是硬条件绕不过去,况且jsp后面的servlet也必须了解,否则看框架的时候很多概念都.

    我是jsp初学者,想初步了解一下ssh框架的定义作用。 在html中,框架的定义.

    html中的框框叫框架,SSH也叫框架,此框架非彼框架。就像java里的接口和电脑里的USB接口一样,都叫接口。你可以把SSH理解成JAVA的一个子项目,就像JAVA分J2.

    我想做一个左右结构的框架,其中点击图片(切换)可以隐藏左边和显示左边。

    用框架啊`````

    在子页面中 调用 parent.document..

    同事给我了一个JSP网上购书系统的工程包,配置好tomcate和MySQL进行测.

    jdbc:mysql://localhost:3306/db_eshop;;;;db_eshop这是你的数据库名字。你的密码改成空了,可能不行,一般在安装数据库第一次配置的时候,会自动让你填写,不填写是.

    更多相关内容
  • 什么是框架和三大框架的介绍

    千次阅读 多人点赞 2020-08-02 18:32:08
    什么是框架: 框架(Framework)是整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法;另一种定义认为,框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。 ...

    什么是框架:
    框架(Framework)是整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法;另一种定义认为,框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。
    可以说,一个框架是一个可复用的设计构件,它规定了应用的体系结构,阐明了整个设计、协作构件之间的依赖关系、责任分配和控制流程,表现为一组抽象类以及其实例之间协作的方法,它为构件复用提供了上下文(Context)关系。因此构件库的大规模重用也需要框架。
    构件领域框架方法在很大程度上借鉴了硬件技术发展的成就,它是构件技术、软件体系结构研究和应用软件开发三者发展结合的产物。在很多情况下,框架通常以构件库的形式出现,但构件库只是框架的一个重要部分。框架的关键还在于框架内对象间的交互模式和控制流模式。
    框架比构件可定制性强。在某种程度上,将构件和框架看成两个不同但彼此协作的技术或许更好。框架为构件提供重用的环境,为构件处理错误、交换数据及激活操作提供了标准的方法。
    应用框架的概念也很简单。它并不是包含构件应用程序的小片程序,而是实现了某应用领域通用完备功能(除去特殊应用的部分)的底层服务。使用这种框架的编程人员可以在一个通用功能已经实现的基础上开始具体的系统开发。框架提供了所有应用期望的默认行为的类集合。具体的应用通过重写子类(该子类属于框架的默认行为)或组装对象来支持应用专用的行为。
    应用框架强调的是软件的设计重用性和系统的可扩充性,以缩短大型应用软件系统的开发周期,提高开发质量。与传统的基于类库的面向对象重用技术比较,应用框架更注重于面向专业领域的软件重用。应用框架具有领域相关性,构件根据框架进行复合而生成可运行的系统。框架的粒度越大,其中包含的领域知识就更加完整。
    框架,即framework。其实就是某种应用的半成品,就是一组组件,供你选用完成你自己的系统。简单说就是使用别人搭好的舞台,你来做表演。而且,框架一般是成熟的,不断升级的软件。
    三大框架:
    Spring、Struts、Hibernate。
    Spring:
    Spring是一个开源框架,它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。

    Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

    轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外,Spring是非侵入式的:典型地,Spring应用中的对象不依赖于Spring的特定类。

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

    面向切面——Spring提供了面向切面编程的丰富支持,允许通过分离应用的业务逻辑与系统级服务(例如审计(auditing)和事务(transaction)管理)进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责(甚至是意识)其它的系统级关注点,例如日志或事务支持。

    容器——Spring包含并管理应用对象的配置和生命周期,在这个意义上它是一种容器,你可以配置你的每个bean如何被创建——基于一个可配置原型(prototype),你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而,Spring不应该被混同于传统的重量级的EJB容器,它们经常是庞大与笨重的,难以使用。

    框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中,应用对象被声明式地组合,典型地是在一个XML文件里。Spring也提供了很多基础功能(事务管理、持久化框架集成等等),将应用逻辑的开发留给了你。

    所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。
    Spring的基本组成:
    1、最完善的轻量级核心框架。

    2、通用的事务管理抽象层。

    3、JDBC抽象层。

    4、集成了Toplink, Hibernate, JDO, and iBATIS SQL Maps。

    5、AOP功能。

    6、灵活的MVC Web应用框架。

    Struts介绍:
    Struts是最早的Java开源框架之一,它是MVC设计模式的一个优秀实现。 Struts定义了通用的Controller(控制器),通过配置文件(通常是 Struts -config.xml)

    Struts是最早的java开源框架之一,它是MVC设计模式的一个优秀实现。 Struts定义了通用的Controller(控制器),通过配置文件(通常是 Struts -config.xml)隔离Model(模型)和View(视图),以Action的概念以对用户请求进行了封装,使代码更加清晰易读。 Struts还提供了自动将请求的数据填充到对象中以及页面标签等简化编码的工具。 Struts能够开发大型Java Web项目。
    Hibernate介绍
    Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全自动的orm框架,hibernate可以自动生成SQL语句,自动执行,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的JaveEE架构中取代CMP,完成数据持久化的重任。
    特点:
    将对数据库的操作转换为对Java对象的操作,从而简化开发。通过修改一个“持久化”对象的属性从而修改数据库表中对应的记录数据。

    提供线程和进程两个级别的缓存提升应用程序性能。

    有丰富的映射方式将Java对象之间的关系转换为数据库表之间的关系。

    屏蔽不同数据库实现之间的差异。在Hibernate中只需要通过“方言”的形式指定当前使用的数据库,就可以根据底层数据库的实际情况生成适合的SQL语句。

    非侵入式:Hibernate不要求持久化类实现任何接口或继承任何类,POJO即可。

    展开全文
  • 该源码包含了很多的实用类库具体的可以参考说明文档。 三、源码特点 采用了Html+JQuery+EasyUI +Ajax+ashx+ado.net的技术。 四、注意事项 1、开发环境为Visual Studio 2010,数据库为SQL Server 2008R2,数据库...
  • ssm框架具体的搭建步骤

    千次阅读 2020-08-19 15:23:27
    ssm环境搭建大纲: 第一步:在pom文件当中导入依赖 第二步:spring环境的搭建 主要配置:开启注解扫描,扫描service层和dao层,不扫描Controller层 第三步:springmvc环境的搭建 1.开启注解扫描,但是只扫描...

    ssm环境搭建大纲:

    第一步:在pom文件当中导入依赖
    第二步:spring环境的搭建
    主要配置:开启注解扫描,扫描service层和dao层,不扫描Controller层
    
    第三步:springmvc环境的搭建
    1.开启注解扫描,但是只扫描Controller
    2.配置视图解析器对象
    3.过滤静态资源
    4.开启注解支持
    
    第四步:spring整合springmvc中web.xml中的配置:
    1.配置监听器,完成加载applicationContext,默认只会加载
    WEB-INF下的applicationContext
    2.配置文件位置
    3.配置前端控制器---->加载springmvc.xml文件------>启动
    服务器,创建servlet
    4.解决中文乱码的过滤器
    
    第五步:mybatis环境搭建(直接在applicationContext.xml文件中搭建,直接整和)
    第六步:spring整和mybatis在applicationContext.xml文件中的配置:
    1.配置连接池
    2.配置SqlSessionFactory工厂
    3.配置IAccountDao位置
    4.配置事务管理器-------->配置事务通知
    5.配置aop增强
    

    log4j.properties文件的配置:

    # Set root category priority to INFO and its only appender to CONSOLE.
    #log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
    log4j.rootCategory=debug, CONSOLE, LOGFILE
    
    # Set the enterprise logger category to FATAL and its only appender to CONSOLE.
    log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
    
    # CONSOLE is set to be a ConsoleAppender using a PatternLayout.
    log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
    log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
    log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
    
    # LOGFILE is set to be a File appender using a PatternLayout.
    log4j.appender.LOGFILE=org.apache.log4j.FileAppender
    log4j.appender.LOGFILE.File=d:\axis.log
    log4j.appender.LOGFILE.Append=true
    log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
    log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n
    

    dbconfig.properties文件的配置:

    jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=CTT
    jdbc.username=root
    jdbc.password=
    

    mybatis-config.xml文件的配置:

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <!--mybatis的一些配置-->
    <configuration>
        <settings>
            <setting name="mapUnderscoreToCamelCase" value="true"/>
        </settings>
        <typeAliases>
            <package name="com.zgw.domain"/>
        </typeAliases>
    </configuration>
    

    applicationContext.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" xmlns:context="http://www.springframework.org/schema/context"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx" 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
    	http://www.springframework.org/schema/aop
    	http://www.springframework.org/schema/aop/spring-aop.xsd
    	http://www.springframework.org/schema/tx
    	http://www.springframework.org/schema/tx/spring-tx.xsd">
        <!--开启注解扫描,只扫描service和dao-->
        <context:component-scan base-package="com.zgw">
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>
        <!--spring整和mybatis-->
        <!--引入数据源外部配置文件-->
        <context:property-placeholder location="classpath:dbconfig.properties"/>
        <!--引入数据源-->
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="driverClass" value="${jdbc.driver}"></property>
            <property name="jdbcUrl" value="${jdbc.url}"></property>
            <property name="user" value="${jdbc.username}"></property>
            <property name="password" value="${jdbc.password}"></property>
        </bean>
        <!--配置SqlSessionFactory工厂-->
        <bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
            <!--注入数据源-->
            <property name="dataSource" ref="dataSource"></property>
            <!--加载mybatis的全局配置文件-->
            <property name="configLocation" value="classpath:mybatis-config.xml"></property>
            <!--指定mybatis的mapper文件的位置-->
            <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
            <!-- 传入PageHelper的插件 -->
            <property name="plugins">
                <array>
                    <bean class="com.github.pagehelper.PageInterceptor">
                        <property name="properties">
                            <props>
                                <prop key="helperDialect">mysql</prop>
                                <prop key="reasonable">true</prop>
                            </props>
                        </property>
                    </bean>
                </array>
            </property>
        </bean>
        <!--配置IAccountDao位置-->
        <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.zgw.dao"></property>
        </bean>
        <!--配置spring框架声明式事务-->
        <!--配置事务管理器-->
        <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="*"/>
                <!--只要是find开头的都是只读-->
                <tx:method name="find*" read-only="true"></tx:method>
            </tx:attributes>
        </tx:advice>
        <!--8. 配置事务切入位置,以及aop增强-->
        <aop:config>
            <aop:pointcut id="p" expression="execution(* com.zgw.service.impl.*.*(..))"/>
            <aop:advisor advice-ref="txadvice" pointcut-ref="p"></aop:advisor>
        </aop:config>
    

    springmvc.xml文件的配置:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xmlns:context="http://www.springframework.org/schema/context"
           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
            http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd">
        <!--开启注解扫描,只扫描Controller-->
        <context:component-scan base-package="com.zgw">
            <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>
        <!--配置视图解析对象-->
        <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/pages/"></property>
            <property name="suffix" value=".jsp"></property>
        </bean>
        <!--过滤静态资源-->
        <!--<mvc:default-servlet-handler/>-->
        <mvc:resources location="/css/" mapping="/css/**" />
        <mvc:resources location="/img/" mapping="/img/**" />
        <mvc:resources location="/plugins/" mapping="/plugins/**" />
        <mvc:resources location="/js/" mapping="/js/**" />
        <!--开启注解支持-->
        <mvc:annotation-driven></mvc:annotation-driven>
    </beans>
    

    web.xml文件的配置:

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns="http://xmlns.jcp.org/xml/ns/javaee"
     xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
             version="3.1">
      <!-- 配置加载类路径的配置文件 -->
      <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:applicationContext.xml,classpath*:spring-security.xml</param-value>
      </context-param>
      <!-- 配置监听器 -->
      <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
      <filter>
        <filter-name>springSecurityFilterChain</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
      </filter>
      <filter-mapping>
        <filter-name>springSecurityFilterChain</filter-name>
        <url-pattern>/*</url-pattern>
      </filter-mapping>
      <!-- 前端控制器(加载classpath:springmvc.xml 服务器启动创建servlet) -->
      <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 配置初始化参数,创建完DispatcherServlet对象,加载springmvc.xml配置文件 -->
        <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <!-- 服务器启动的时候,让DispatcherServlet对象创建 -->
        <load-on-startup>1</load-on-startup>
      </servlet>
      <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
      </servlet-mapping>
      <!-- 解决中文乱码过滤器 -->
      <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
          <param-name>encoding</param-name>
          <param-value>UTF-8</param-value>
        </init-param>
      </filter>
      <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
      </filter-mapping>
      <welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>index.jsp</welcome-file>
        <welcome-file>default.html</welcome-file>
        <welcome-file>default.htm</welcome-file>
        <welcome-file>default.jsp</welcome-file>
      </welcome-file-list>
    </web-app>
    

    dao层的映射配置文件:

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.zgw.dao.IUserDao">
    
        <!-- 配置 查询结果的列名和实体类的属性名的对应关系 -->
        <resultMap id="userMap" type="uSeR">
            <!-- 主键字段的对应 -->
            <id property="userId" column="id"></id>
            <!--非主键字段的对应-->
            <result property="userName" column="username"></result>
            <result property="userAddress" column="address"></result>
            <result property="userSex" column="sex"></result>
            <result property="userBirthday" column="birthday"></result>
        </resultMap>
        <!-- 了解的内容:抽取重复的sql语句-->
        <sql id="defaultUser">
            select * from user
        </sql>
        <!-- 查询所有 -->
        <select id="findAll" resultMap="userMap">
            <include refid="defaultUser"></include>
        </select>
    <!-- 保存用户 -->
        <insert id="saveUser" parameterType="user">
            <!-- 配置插入操作后,获取插入数据的id -->
            <selectKey keyProperty="userId" keyColumn="id" resultType="int" order="AFTER">
                select last_insert_id();
            </selectKey>
            insert into user(username,address,sex,birthday)values(#{userName},#{userAddress},#{userSex},#{userBirthday});
        </insert>
        <!-- 更新用户 -->
        <update id="updateUser" parameterType="USER">
            update user set username=#{userName},address=#{userAddress},sex=#{userAex},birthday=#{userBirthday} where id=#{userId}
        </update>
        <!-- 删除用户-->
        <delete id="deleteUser" parameterType="java.lang.Integer">
            delete from user where id = #{uid}
        </delete>
        <!-- 根据id查询用户 -->
        <select id="findById" parameterType="INT" resultMap="userMap">
            select * from user where id = #{uid}
        </select>
        <!-- 根据名称模糊查询 -->
        <select id="findByName" parameterType="string" resultMap="userMap">
              select * from user where username like #{name}
       </select>
        <!-- 根据queryVo的条件查询用户 -->
        <select id="findUserByVo" parameterType="com.itheima.domain.QueryVo" resultMap="userMap">
            select * from user where username like #{user.userName}
        </select>
        <!-- 根据条件查询
        <select id="findUserByCondition" resultMap="userMap" parameterType="user">
            select * from user where 1=1
            <if test="userName != null">
              and username = #{userName}
            </if>
            <if test="userSex != null">
                and sex = #{userSex}
            </if>
        </select>-->
        <select id="findUserByCondition" resultMap="userMap" parameterType="user">
            select * from user
            <where>
                <if test="userName != null">
                    and username = #{userName}
                </if>
                <if test="userSex != null">
                    and sex = #{userSex}
                </if>
            </where>
        </select>
        <!-- 根据queryvo中的Id集合实现查询用户列表 -->
        <select id="findUserInIds" resultMap="userMap" parameterType="queryvo">
            <include refid="defaultUser"></include>
            <where>
                <if test="ids != null and ids.size()>0">
                    <foreach collection="ids" open="and id in (" close=")" item="uid" separator=",">
                        #{uid}
                    </foreach>
                </if>
            </where>
        </select>
    </mapper>
    

    pom.xml文件的配置:

    <?xml version="1.0" encoding="UTF-8"?>
    
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
    
      <groupId>com.zgw</groupId>
      <artifactId>ssmdemo</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>war</packaging>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>5.0.2.RELEASE</spring.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <mysql.version>5.1.6</mysql.version>
        <mybatis.version>3.4.5</mybatis.version>
      </properties>
    
      <dependencies>
    
        <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-web</artifactId>
          <version>5.0.1.RELEASE</version>
        </dependency>
        <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-config</artifactId>
          <version>5.0.1.RELEASE</version>
        </dependency>
    
        <dependency>
          <groupId>org.aspectj</groupId>
          <artifactId>aspectjweaver</artifactId>
          <version>1.6.8</version>
        </dependency>
    
        <dependency>
          <groupId>com.github.pagehelper</groupId>
          <artifactId>pagehelper</artifactId>
          <version>5.1.2</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-aop</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-web</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-webmvc</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-test</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-tx</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>${spring.version}</version>
        </dependency>
    
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
          <scope>compile</scope>
        </dependency>
    
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>${mysql.version}</version>
        </dependency>
    
        <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>servlet-api</artifactId>
          <version>2.5</version>
          <scope>provided</scope>
        </dependency>
    
        <dependency>
          <groupId>javax.servlet.jsp</groupId>
          <artifactId>jsp-api</artifactId>
          <version>2.0</version>
          <scope>provided</scope>
        </dependency>
    
        <dependency>
          <groupId>javax.annotation</groupId>
          <artifactId>jsr250-api</artifactId>
          <version>1.0</version>
        </dependency>
    
        <dependency>
          <groupId>jstl</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</version>
        </dependency>
    
        <!-- log start -->
        <dependency>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
          <version>${log4j.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-api</artifactId>
          <version>${slf4j.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.slf4j</groupId>
          <artifactId>slf4j-log4j12</artifactId>
          <version>${slf4j.version}</version>
        </dependency>
    
        <!-- log end -->
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>${mybatis.version}</version>
        </dependency>
    
        <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis-spring</artifactId>
          <version>1.3.0</version>
        </dependency>
        <dependency>
          <groupId>c3p0</groupId>
          <artifactId>c3p0</artifactId>
          <version>0.9.1.2</version>
          <type>jar</type>
          <scope>compile</scope>
        </dependency>
        <dependency>
          <groupId>org.springframework.security</groupId>
          <artifactId>spring-security-taglibs</artifactId>
          <version>5.0.1.RELEASE</version>
        </dependency>
      </dependencies>
    </project>
    
    展开全文
  • 该文档是基于python的自动化测试框架的搭建,详细介绍了框架具体信息以及各个模块的含义,对于最终搭建该框架起到重要作用。
  • 这是一个基于ssm框架的图书管理系统的项目,项目中使用到了mysql数据库,使用maven进行jar包的导入,前端使用bootstrap框架进行开发,适合对于ssm框架感兴趣的同学使用,是一个基于ssm框架的入门项目。里面配有项目...
  • 具体框架测试界面测试界面具体框架测试界面测试界面具体框架测试界面测试界面具体框架测试界面测试界面具体框架测试界面测试界面具体框架测试界面测试界面具体框架测试界面测试界面具体框架测试界面...
  • 基于SSM框架下的注册登录系统,基本功能都实现了,毕竟入门级的代码,还有一点瑕疵,具体可以参照博客学习,还有代码演示。
  • ​Vue(框架)介绍​

    千次阅读 2021-10-22 13:34:26
    前言,关于Vue框架 很多地方都称Vue框架,按我的理解其实叫做Vue类库更合适,这边标题遵循传统叫法,称Vue框架,并且在后面补充加了个括号。 介绍Vue之前,必须先介绍Node.js,Vue的源代码是在Node下面编译成通常...

    前言,关于Vue框架

    很多地方都称Vue框架,按我的理解其实叫做Vue类库更合适,这边标题遵循传统叫法,称Vue框架,并且在后面补充加了个括号。

    介绍Vue之前,必须先介绍Node.js,Vue的源代码是在Node下面编译成通常意义网页的。

    一、传统的JavaScript

    传统的js是运行在浏览器上的,因为浏览器内核分为两个部分:

    渲染引擎---渲染HTML和CSS;

    JavaScript 引擎---负责运行 JavaScript,随着技术的发展, Chrome 使用的 JavaScript 引擎是 V8,它的速度非常快且性能好,同时由2009年5月Ryan Dahl开发的Node.js 诞生。

    二、什么是Node.js?

    Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。Node.js 使用了一个事件驱动、非阻塞式 I/O 的模型,使其轻量又高效。 

    Node 是一个让 JavaScript 运行在服务端的开发平台,它让 JavaScript 成为与PHPPythonPerlRuby 等服务端语言平起平坐的脚本语言。 发布于2009年5月,由Ryan Dahl开发,实质是对Chrome V8引擎进行了封装。

    Node对一些特殊用例进行优化,提供替代的API,使得V8在非浏览器环境下运行得更好。V8引擎执行Javascript的速度非常快,性能非常好。 Node是一个基于Chrome JavaScript运行时建立的平台, 用于方便地搭建响应速度快、易于扩展的网络应用。Node 使用事件驱动, 非阻塞I/O 模型而得以轻量和高效,非常适合在分布式设备上运行数据密集型的实时应用。

    官网上对其特点描述为:

    1. 它是一个Javascript运行环境

    2. 依赖于Chrome V8引擎进行代码解释

    3. 事件驱动

    4. 非阻塞I/O

    5. 轻量、可伸缩,适于实时数据交互应用

    6. 单进程,单线程

    相对于传统的JavaScript来说,Node.js 是一个运行在服务端的框架,它的底层就使用了 V8 引擎。我们知道 Apache + PHP 以及 Java 的 Servlet 都可以用来开发动态网页,Node.js 的作用与他们类似,只不过是使用 JavaScript 来开发,它大大提升了开发的性能以及便利。

    (1)使用node开发还可以使用node自有配套的npm包管理工具:
    NPM是随同NodeJS一起安装的包管理工具,能解决NodeJS代码部署上的很多问题,常见的使用场景有以下几种:
    允许用户从NPM服务器下载别人编写的第三方包到本地使用。
    允许用户从NPM服务器下载并安装别人编写的命令行程序到本地使用。
    允许用户将自己编写的包或命令行程序上传到NPM服务器供别人使用。

    Node.js 的使用包管理器 npm来管理所有模块的安装、配置、删除等操作,使用起来非常方便。

    (2)node本身就是一个服务端的框架,对于一些简单的项目,我们可以不需要后端配合,直接用node进行数据库的增删改查(但是我们一般不使用这个功能);

    (3)nodejs是一个服务js平台,有自身带的npm(基于 Node.js的前端项目包管理工具),有第三方的grunt(基于 Node.js的前端项目构建工具即即脚手架)、有第三方的express(路由功能)等强大的代码与项目管理应用。还有自身带的webpack(基于 Node.js的前端项目部署打包工具),v8(谷歌客户端浏览器javascript引擎)等强大的功能。

    npm(包管理工具)是基于 Node.js的前端项目包管理工具,是项目中对各种程序包的依赖管理,传统的开发项目主要是后端,现在技术在更新,前端有了框架的开发模式管理,也需要用包管理工具的思想去管理,目的是简化第三方程序包在项目中引用复杂化。前端的js包是全世界JavaScript 天才开发共享的各种代码模块,把这些代码模块都按照一个独立的软件功能统一在一个库中,一个代码模块是一个程序包(package,即代码模块)。它是世界上最大的软件注册表,每星期大约有 30 亿次的下载量,包含超过 600000 个 包(package) (即,代码模块),使用包的结构使您能够轻松跟踪依赖项和版本。  官网: https://www.npmjs.cn/

    webpack是基于 Node.js的前端项目部署打包工具。

    grunt是基于 Node.js的前端JavaScript语言项目构建工具,即脚手架。一句话:构建项目自动化。对于需要反复重复的任务,例如压缩(minification)、编译、单元测试、linting等,自动化工具可以减轻你的劳动,简化你的工作。当你在 Gruntfile 文件正确配置好了任务,任务运行器就会自动帮你或你的小组完成大部分无聊的工作。官网:https://www.gruntjs.net/

    Express 是一个保持最小规模的灵活的 Node.js Web 应用程序开发框架,为 Web 和移动应用程序提供一组强大的功能。

    三、Vue

    首先vue.js 是库,不是框架,不是框架,不是框架。

    Vue.js 使用了基于 HTML 的模版语法,允许开发者声明式地将 DOM 绑定至底层 Vue 实例的数据。

    Vue.js 的核心是一个允许你采用简洁的模板语法来声明式的将数据渲染进 DOM 的系统。

    vue.js 支持路由功能开发的 叫vue-route.js,vue.js支持数据请求功能开发的 叫vue-resource.js,李祥需求查资料求证?

    vue.js 下载过来直接在html中引入就能使用,并不一定要npm install vue,那仕么业务开发需求场景下需要使用NPM呢?NPM是仕么?

    Vue.js可以在html里直接引用后使用,等到与Vue一起配合使用的第三方应用的库或框架多起来后,一个个从html里引入就不方便了,所有要借用node.js中的npm管理包的引入,是方便包管理。

    使用Vue.js开发的前端项目如何部署?我们用到node.js中的程序打包工具比如webpack(node.js中的程序部署打包工具),可以直接require引入之后将不同模块打包成单个js文件。同时这些工具提供各种自动化处理,让前端开发更爽。

    Vue.js是数据驱动,和JQuery思路不同,你几乎不需要自己进行复杂低效的dom操作,开发简介明了。从这一点上说,可以基本抛弃JQuery了。

    Vue.js开发有第三方支持的项目构建工具,vue-cli脚手架

    通过上面的分析,与其说是VUE需要借助NODE开发前端项目,不如换个思路,在NODE中集成VUE开发前端项目,所以,先安装Node,使用Node的npm先安装Vue,然后再安装vue-cli脚手架,最后通过vue-cli脚手架构建前端项目。

     再扩展一下思路:

    上述我们解读了Vue与Node的关系,从他们之间的关系,刨根问底,这个问题的本质是前端开发思想的问题,传统前端开发只是CSS、CSS3、HTML、HTML5、传统JS、面向对象JS(类似jQuery类库)的开发,前端技术在近几年发展迅速,如今的前端开发己不再是 10 年前写个 HTML 和 css 那样简单 了,新的概念层出不穷,比如 ECMAScript 6、 Node.js、 NPM、前端工程化、轻量级模板引擎、模块化(如vue模块vue-require.js)、组件化、预编译、双向数据绑定、路由(如vue路由vue-route.js、前端路由的框架通用的有 Director、Angular 的 ngRouter、React 的 ReactRouter)、状态管 理、动画、、 SSR、前后端分离开发等。这些新东西在不断 优化我们的开发模式,改变我们的编程思想。 随着这些技术的普及,出现一套可称为“万金油”的技术技被许多商业项目用于生产环境:

    jQuery + RequireJS ( SeaJS ) + artTemplate (doT) +Gulp (Grunt)是一种前端开发方案


    这套技术战以 jQuery 为核心,能兼容绝大部分浏览器,这是很多企业比较关心的,因为他们 的客户很可能还在用 IE7 及以下浏览器。使用 RequireJS 或 SeaJS 进行模块化开发可以解决代码依 赖混乱的问题, 同时便于维护及团队协作。使用轻量级的前端模板(如 doT)可以将数据与 HTML 模板分离。最后,使用自动化构建工具(如 Gulp)可以合并压缩代码,如果你喜欢写 Less、 Sass 以及现在流行的 ES 6,也可以帮你进行预编译。 这样一套看似完美无瑕的前端解决方案就构成了我们所说的传统前端开发模式,由于它的简 单、 高效、实用, 至今仍有不少开发者在使用。不过随着项目的扩大和时间的推移,出现了更复杂 的业务场景,比如 SPA (单页面富应用〉 、 组件解稍等。为了提升开发效率,降低维护成本,传 统的前端开发模式己不能完全满足我们的需求,这时就出现了如 Angular、 React 以及我们要介绍 的主角 Vue 。

            从综合解决方案来讲,Node.js迈出第一步,为前端工程化开发奠定了基础,基于Node提供了项目脚手架、打包工具、包管理工具等等,基于Node诞生了Vue、Angular、 React等前端开发思想,以及组装搭配的前端开发方案。

             在 Node.js 出现后,jQuery + RequireJS ( SeaJS ) + artTemplate (doT) +Gulp (Grunt)开发组合又有了改善,就是所谓的大前端,得益于 Node.js 和 JavaScript 的语 言特性, html 模板可以完全由前端来控制,同步或异步渲染完全由前端自由决定,并且由前端维 护一套模板,这就是为什么在服务端使用 artTemplate、 React 以及 Vue2 的原因。说了这么多,到 底怎样算是 SPA 呢?其实就是在前后端分离的基础上,加一层前端路由。

             前端路由,即由前端来维护一个路由规则。实现有两种,一种是利用 url 的 hash, 就是常说的 锚点(刑, JavaScrip/通过 hashChange 事件来监听 url 的改变, IE7 及以下需要用轮询:另一种就是 HTML5 的 History 模式,它使 url 看起来像普通网站那样,以“/”分剖,没有#,但页面并没有 跳转,不过使用这种模式需要服务端支持,服务端在接收到所有的请求后,在fl指向同一个 html 文 件,不然会出现 404。因此, SPA 只有一个 ht时,整个网站所有的内容都在这一个 html 里,通过 JavaScript 来处理。 前端路由的优点有很多,比如页面持久性,像大部分音乐网站,你都可以在播放歌曲的同时 跳转到别的页面,而音乐没有中断。再比如前后端彻底分离。前端路由的框架通用的有 Director (ht刷://github.com/flatiron/director ),不过更多还是结合具体框架来用,比如 Angular 的 ngRouter, React 的 ReactRouter,以及本节要介绍的 Vue 的 vue-router。 如果要独立开发一个前端路由,需要考虑到页面的可插拔、页面的生命周期、内存管理等 问题。

    Node的webpack打包的核心思想就是单页面富应用(SPA) 。 SPA 通常是由一个 html 文件和一堆按需 加载的 js 组成,它的 html 结构可能会非常简单,比如:
    <!DOCTYPE html>

    <html lang=”zh-CN”>

    <head>

    <meta charset=”UTF-8”>

    <title>webpack app</title>

    <link rel=” stylesheet” href=”dist/mai口 .css ”>

    </head>

    <body>

    <div id=” app”></div> <script type=”text/javascript” src=”dist/main.j s ”></lcript>
    </body>

    </html>
    看起来很简单是吧?只有一个<div>节点,所有的代码都集成在了神奇的 main扣 文件中,理论 上古可以实现像知乎、淘宝这样大型的项目。 在开始讲解 webpack 的用法前,先介绍两个 ES6 中的语法 export 和 impo此, 因为在后面会大 量使用,如果对它不了解,可能会感到很困惑。 export 和 import 是用来导出和导入模块的。 一个模块就是一个js 文件,它拥有独立的作用域, 里面定义的变量外部是无法获取的。比如将一个配置文件作为模块导出,示例代码如下:

     以上几个示例中,导入的模块名称都是在 export 的文件中设置的,也就是说用户必须预先知道 这个名称叫什么,比如 Config、 add。而有的时候,用户不想去了解名称是什么,只是把模块的功能 拿来使用,或者想自定义名称,这时可以使用 export default 来输出默认的模块。示例代码如下:

     Node+Vue+ VueRequire+VueRoute+VueCli就是流行的前端开发方案。

    Vue项目框架的搭建

    1、安装node.js

    直接百度搜索或者在其中文官网也可以下载下载 | Node.js 中文网 ,在安装完node之后npm包管理工具也自动的安装好,安装完之后,在命令行输入node -v或者npm -v,出现版本号说明安装成功。如下图所示:

    2、改变原有的环境变量
    (1)配置npm的全局模块的存放路径以及cache的路径,在nodejs的主目录下新建"node_global"及"node_cache"两个文件夹,例如两个文件夹放在NodeJS的主目录下,便在NodeJs下建立"node_global"及"node_cache"两个文件夹,输入以下命令改变npm配置。

     然后输入如下两个命令:

    npm config set prefix “E:\commontool\nodejs\node_global”
    npm config set cache “E:\commontool\nodejs\node_cache”

    (2)在node_global文件夹下新建node_modules文件夹,系统环境变量Path中添加路径E:\commontool\nodejs\node_global\node_modules,此后所安装的模块都会安装到改路径下。

    (3)在命令行输入以下命令试着安装express(注:“-g”这个参数意思是装到global目录下,也就是上面说设置的“E:\commontool\nodejs\node_global”里面。)

        npm install express -g
       安装完毕后可以看到.\node_global\node_modules\express 已经有内容

     (4)控制台cd进入E:\commontool\nodejs\node_global\node_modules\express路径下,在命令行输入node进入编辑模式,输入以下代码测试是否能正常加载模块:
    require(‘express’)  ,假设成功,可以看到有输出。假设出错,检查NODE_PATH的路径。

    3、安装淘宝npm(cnpm)

    (1)输入以下命令
    npm install -g cnpm --registry=https://registry.npm.taobao.org

    (2)添加系统变量path的内容
    因为cnpm会被安装到E:\commontool\nodejs\node_global下,而系统变量path并未包含该路径。在系统变量path下添加该路径即可正常使用cnpm;如下图配置:

     (3)输入cnpm -v输入是否正常。

    4、vue-cli的搭建

    打开cmd ,敲入命令:
    cnpm install --global vue-cli (–global:全局安装)

    安装成功后输入vue -V出现版本号证明安装成功。

    5、vue的命令

    安装依赖cnpm install,注意,一般用的是cnpm;如果平常时开发就跑npm run dev(本地开发跑代码),如果需要打包则跑npm run build

    安装调试界面:

    cnpm i -g @vue/cli
    
    cnpm install -g @vue/cli

    安装成功后命令 vue ui,打开调试工具。

    展开全文
  • MVC框架

    千次阅读 2021-10-10 18:44:44
    MVC框架MVC框架——个人理解,不管啦(头大,越研究越头大)1 经典MVC框架2 经典mvc模式就是jsp+servlet+JavaBean3 JavaBean4 实际MVC框架应用5 总结 MVC框架——个人理解,不管啦(头大,越研究越头大) 注意:mvc...
  • Java框架总结

    万次阅读 多人点赞 2020-01-17 14:14:13
    本系列用来记录常用java框架的基本概念、区别及联系,也记录了在使用过程中,遇到的一些问题的解决方法,方便自己查看,也方便大家查阅。 欲速则不达,欲达则欲速! 一、SSH 1、基本概念 SSH框架是JAVA EE中三种...
  • OAuth 2.0授权框架详解

    万次阅读 热门讨论 2020-11-24 09:59:27
    今天,我们将要讲解一下OAuth 2.0授权框架的构成,希望大家能够喜欢。 OAuth的构成 在传统的CS模式的授权系统中,如果我们想要借助第三方系统来访问受限的资源,第三方系统需要获取到受限资源服务器的用户名和密码...
  • Mybatis 框架

    千次阅读 2021-08-31 22:09:16
    Mybatis 框架 第1章 框架概述 1.1 什么是框架 1.1.1 什么是框架 框架(Framework)是整个或部分系统的可重⽤设计,表现为⼀组抽象构件及构件实例间交互的⽅法;另⼀种定义认为,框架是可被应⽤开发者定制的应⽤骨架。...
  • ssm框架搭建和整合流程

    千次阅读 2021-01-19 21:29:35
    Spring + SpringMVC + Mybatis整合流程1 需求1.1 客户列表查询1.2 根据客户姓名模糊查询2 整合思路第一步:整合dao层Mybatis和spring整合,通过spring管理mapper接口,使用mapper扫描器自动扫描mapper接口,并在...
  • Django框架详解

    千次阅读 2021-06-18 14:02:33
    一、MVC框架 1、MVC框架核心思想: 分工和解耦 2、web MVC举例: 以通过浏览器注册用户信息为例: M:Model,模型, 和数据库进行交互。 V:View,视图, 产生html页面。 C:Controller,控制器, 接收请求,进行处理...
  • EF框架的使用

    千次阅读 热门讨论 2021-03-19 18:45:50
    1、首先创建一个控制台程序, 2、程序右键安装 点击-管理NUGet程序包,浏览-搜索-EF ... EF框架会自动生成实体。实体得属性与数据库一一对应。 8、控制台,Main方法,可以向数据库增加信息。 ...
  • 一个免费的java权限后台管理系统框架

    千次下载 热门讨论 2015-01-23 17:52:35
    java权限后台开发框架,采用spring + srpingsecurity + springMVC + Hibernate + freemarker + jquery 等技术实现,页面及源文件打包发布程序。 完整的功能应用,包括:后台权限、人员机构、参数代码、角色权限、...
  • webrtc整体框架

    千次阅读 2022-03-07 20:22:27
    本文主要目的是了解WebRTC的整体框架,为后续深入学习WebRTC框架打下基础。 2 整体框架介绍 WebRTC目前比较普遍的框架描述如下图所示,WebRTC整体架构从上到下一共分为三层,最上层是WbeAPI层,这一层是暴露给开发...
  • SSM开发框架

    热门讨论 2012-03-03 17:04:48
    05、框架实现了文件上传共通、电子文档导出、校验、全局异常处理、分页等共通,具体参见相关画面的相关功能; 06、通过注解方式实现事务控制,相关画面有测试代码,具体在哪可以自己找一下; 07、关于数据库链接,...
  • 【游戏开发框架】自制Unity通用游戏框架UnityXFramework,详细教程(Unity3D技能树 | tolua | 框架 | 热更新)
  • 几大主流的前端框架(UI/JS)框架

    万次阅读 2020-12-14 11:03:25
    如今的前端已经不再像以前一样就是简单的写写页面和调调样式而已,现在的前端越来越复杂,知识点越来越丰富。...web前端发展至今,演变出了无数的库和框架;说到库第一时间想到的是不是jquery?在小编刚接触库的时候
  • 每一个测试人员都应该了解每种框架的优缺点,以帮助你的团队更好地确定最适合的测试的框架,以达到事半功倍。
  • Flask框架

    万次阅读 2022-01-02 13:19:09
    flask框架是python中的一个轻量级的前后端开发框架,不同于Django,flask只提供基础的功能,其他的功能需要安装各种插件。因为轻量,所以可以用来做一些小工程和低流量的开发;大型工程也可以使用flask框架,但是就...
  • 功能测试框架

    万次阅读 多人点赞 2020-10-05 22:43:15
    测试用例的编写需要按照一定的思路进行,而不是想到哪写到哪,一般测试机制成熟的公司都会有公司自己自定义的测试用例模板,以及一整套的测试流程关注点,当然我们自己在测试生涯中也应当积累一套自己的测试框架,...
  • 2021 跨平台开发框架到底哪家强?...目前来看比较火的应该是 Flutter,次之 RN,具体还要看企业的应用场景和领域,AVM,Ionic,NativeScript 在不少企业和个人开发者中也使用率较高。 一,安装环境
  • 简述SSM框架与SSH框架

    万次阅读 多人点赞 2019-06-27 17:21:43
    简述SSM框架与SSH框架 一. 简介SSM框架 SSM(Spring+SpringMVC+MyBatis)框架集由Spring、MyBatis两个开源框架整合而成(SpringMVC是Spring中的部分内容)。常作为数据源较简单的web项目的框架。 Spring  Spring就...
  • SSM框架详解

    千次阅读 多人点赞 2022-02-11 13:04:56
    SSM框架详解,实例解释
  • SSM框架介绍

    万次阅读 多人点赞 2018-10-30 13:01:27
    1、SSM框架简介 SSM框架是Spring MVC ,Spring和Mybatis框架的整合,是标准的MVC模式,将整个系统划分为表现层,Controller层,Service层,DAO层四层,使用Spring MVC负责请求的转发和视图管理,Spring实现业务对象...
  • 什么是框架(包括前端框架和后端框架) 什么是框架 框架(Framework)是整个或部分系统的可重用设计,表现为一组抽象构件及构件实例间交互的方法;另一种定义认为,框架是可被应用开发者定制的应用骨架。前者是从应用...
  • 亲自动手写一个深度学习框架

    千人学习 2018-10-30 15:24:47
    具体安排如下: 1.板书完成数学推导,同时画图讲解; 2.基础:Python实现多层感知器; 3.进阶:C++实现深度学习框架; 4.穿插讲解重点的Python、C++知识。 我相信这次学习能给大家带来不一样的体验!!!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,111,594
精华内容 444,637
关键字:

具体框架