• 今天总结一下前端使用react框架,后台使用mybatis集成springBoot结合使用的要点以及我认为重要的点。 注意:我的程序代码:JDK是1.8版本,前端的是es6版本的(与es5区别:定义函数的格式不同等等)一、mybatis...

      今天总结一下前端使用react框架,后台使用mybatis集成springBoot结合使用的要点以及我认为重要的点。

       注意:我的程序代码:JDK是1.8版本,前端用的是es6版本的(与es5区别:定义函数的格式不同等等)

    一、mybatis集成springBoot的注意事项

    1、需要自己写SQL语句--先建好所需要的数据库表(可以使用逆向工程生成mapper.xml文件,实体类,dao接口),不过最好是自己写SQL语句


    2、使用myBatis时,dao层不需要写实现类,只需写对应的接口类即可。

    注意:接口类中的方法名和mapper.xml中的SQL语句的id值必须一致

    mapper.xml文件:


    dao接口层:


    二、前后台交互(react作为前端框架,springBoot作为后台框架)

    1.后台必须注意Controller层中的@RequestMapping("/xx")

    2.react代码中:package.json文件中添加(防止跨域): "proxy":"http://127.0.0.1:8080"--类似这样的后台域名

    3.react中表格的字段对应于实体类中的属性,必须保持一致

    4.在react代码中添加与后台交互数据的代码:

    // 请求后台数据
      componentWillMount(){
        /* 查询数据的格式 */
        let filter={
           object:{
             object:{
    
             }
           }
        }
        var getInformation ={
          method:"POST",
          headers:{
          "Content-Type":"application/json"
          },
          /* json格式转换 */
          body:JSON.stringify(filter)
          }
          //注意:/org/find的方法名对应于后台Controller层中的RequestMapping
          fetch("/org/find",getInformation)
          .then(response => response.json())
          .then(json =>{
            // 返回的数据类型
          this.setState({
              object:json.object.list
          })
          })
      }

         上述代码是关于查询页面的函数,其中增加、修改、删除一般情况下点击按钮保存,数据保存到数据库并能显示到页面,进而达到更新数据,就会显示所操作的所有数据。

       以上是我的总结,希望可以提出宝贵的意见。

    展开全文
  • react前后端同构渲染

    2017-04-01 16:49:56
    前后端同构渲染:当客户端请求一个包含React组件页面的时候,服务端首先响应输出这个页面,客户端和服务端有了第一次交互。然后,如果加载组件的过程需要向服务端发出Ajax请求等,客户端和服务端又进行了一次交互,...

    前后端同构渲染:当客户端请求一个包含React组件页面的时候,服务端首先响应输出这个页面,客户端和服务端有了第一次交互。然后,如果加载组件的过程需要向服务端发出Ajax请求等,客户端和服务端又进行了一次交互,这样,耗时相对较长。前后端同构渲染可以在页面初次加载时把所有地方渲染好一次性响应给客户端

    实现方式:保证包管理工具和模块依赖方式一致
    包管理工具-npm管理,保证前后端都使用同一个兼容包
    模块依赖方式-webpack,保证前后端都采用commonjs的依赖方式,确保代码可以互相依赖

    服务端如何渲染:
    react全家桶:react、react-router、redux
    react 和 reactDOM
    reactDOM在这里提供的支持就是reactDOM.render和reactDOM.renderToString函数,其中欠着会在浏览器生成DOM结构,后者会在服务端生成对应的HTML字符串模板。react会在生成的DOM结构上添加一个 data-react-checksum的属性,这是一个 adler32 算法的校验和,用以确保两份模板的一致性。
    这里写图片描述
    同时 react 的生命周期在前后端渲染过程中也有所不同。前端渲染的组件拥有完整的生命周期,而后端渲染仅有 componentWillMount 的生命周期。这就意味着,如果我们想进行前后端共同操作的逻辑,如发送数据请求等,可以放在 componentWillMount 的生命周期中;如果想单独处理客户端的逻辑,可以放在其他生命周期,如 componentDidMount 中。

    react-router
    react-router是react的路由-视图控制库,可以书写边界的声明式路由以控制不同页面的渲染。react-router 本身是一个状态机,根据配置好的路由规则,和输入的 url 路径,通过 match 方法找到对应的组件并进行渲染。
    这里写图片描述

    这套机制在前端和后端都是相通的,例如在后端,就是下面这样一种实现形式来进行渲染:

    app.use(async (ctx, next) => {
    match({
    location: ctx.originalUrl,
    routes
    }, callback)
    // 渲染完成之后,调用 callback 回调
    // 将 组件 renderToString 返回前端即可
    })
    对于前端来说,其实也是处理的上面这些逻辑,不过它被很好的封装在 组件中,我们只需要写好声明式的路由,这一切就可以随着 url 的变化自动发生。

    redux
    redux是react的数据流管理库,他对服务端渲染的支持很简单,就是单一的store和状态可初始化。后端在进行渲染的时候会构建好单一的store,并将构建好的初始状态通过以json格式,通过全局变量写到生成好的html字符串模板上。
    前端通过获取初始状态,生成跟后端徐然完成后一模一样的store,就可以保证前后端渲染数据的一致性,以确保前后端生成的dom结构一致。

    优化结果:
    开发效率低的问题:同构应用只有一个项目和一套技术栈,只要拥有 react 开发经验,就可以快速投入前端和后端的开发当中;
    可维护性差的问题:同构应用可以进行大量的代码公用,包括工具方法、常量、页面组件和 redux 的大部分逻辑等,可重用性大大提高; 首屏性能、SEO 等

    处理过程:
    客户端发出请求-服务端渲染出组件-返回给客户端
    1、在需要同构直出的页面(比如是index.html)放上占位符

    <div id="root">@@@</div>
    ###

    以上,当客户端发出首次请求,服务端渲染出组件的html内容放@@@这个位置,然后服务端再渲染出类似这样的js代码段把组件最终渲染到DOM上。也就是说,renderApp方法实际上就是在渲染组件。

    2、而为了直接调用renderApp方法,必须让renderApp方法成为window下的方法

    window.renderApp = function(){ReactDOM.render(...)}

    3、服务端取出index.html,渲染出占位符的内容,替代占位符,并一次性响应给客户端

    案例

    文件结构

    browser.js(在这里把渲染组件的过程赋值给window.renderApp)
    bundle.js(把browser.js内容bundle到这里)
    Component.js(组件在这里定义)
    express.js(服务端)
    index.html(同构直出的页面)
    package.json

    index.html,直出页面放上占位符

    <!doctype html>
    <html>
    <head>
        <meta charset="UTF-8">
        <title>Untitled Document</title>
    </head>
    <body>
    
        <div id="root">@@@</div>
        <script src="bundle.js"></script>
        ###
    </body>
    </html>

    Component.js,在这里定义组件

    var React = require('react');
    var ReactDOM = require('react-dom');
    
    var Component = React.createClass({
        clickHandler: function(){
            alert(this.props.msg)
        },
    
        render: function(){
            return React.createElement('button', {onClick: this.clickHandler}, this.props.msg)
        }
    
    })
    
    module.exports = Component;

    browser.js,把组件渲染过程赋值给window对象

    var React = require('react');
    var ReactDOM = require('react-dom');
    
    var Component = React.createFactory(require('./Component'));
    
    window.renderApp = function(msg){
        ReactDOM.render(Component({msg: msg}), document.getElementById('root')); 
    }

    可以通过来触发组件的渲染。稍后,在服务端会把这段代码渲染出来。

    express.js,服务端

    以上,需要直出的页面有了占位符,定义了组件,并把渲染组件的过程赋值给了window对象,服务端现在要做的工作就是:生成组件的html和渲染组件的js,放到直出页面index.html的占位符位置。

    var express  = require('express');
    var React = require('react');
    var ReactDOMServer = require('react-dom/server');
    var fs = require('fs');
    var Component = React.createFactory(require('./Component'));
    
    //原先把文件读出来
    var BUNDLE = fs.readFileSync('./bundle.js',{encoding:'utf8'});
    var TEMPLATE = fs.readFileSync('./index.html',{encoding:'utf8'});
    
    var app = express();
    
    function home(req, res){
        var msg = req.params.msg || 'Hello';
        var comp = Component({msg: msg});
    
        //@@@占位符的地方放组件
        var page = TEMPLATE.replace('@@@', ReactDOMServer.renderToString(comp));
    
        //###占位符的地方放js
        page = page.replace('###', '<script>renderApp("'+msg+'")</script>')
        res.send(page);
    }
    
    //路由
    app.get('', home);
    app.get('/bundle.js', function(req, res){
        res.send(BUNDLE);
    })
    app.get('/:msg', home);
    
    app.listen(4000);

    package.json中的配置

    "scripts": {
    "start": "watchify ./browser.js -o ./bundle.js"
    },

    启动方式
    运行:npm start
    运行:node express.js
    浏览:localhost:4000

    展开全文
  • 一、搭建springboot后台 1. 创建一个Springboot项目, 然后导入pom依赖, 本着一切从简的原则,如果不连接数据库的话,有个spring-boot-starter-web的依赖就够用了。 <!--mybatis--> ...

    一、搭建springboot后台

    1. 创建一个Springboot项目, 然后导入pom依赖, 本着一切从简的原则,如果不连接数据库的话,有个spring-boot-starter-web的依赖就够用了。 

            <!--mybatis-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.1.1</version>
            </dependency>
    
            <!--MySql连接驱动-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>

    2. 因为是前后端分离开发,所以React不放在springboot目录下, 如果要连接数据库

    application.properties配置
    
    #数据库连接信息
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8
    spring.datasource.username=root
    spring.datasource.password=root
    
    #配置mybatis信息
    mybatis.type-aliases-package=com.jarvis.springboot_mybatis.Entity
    mybatis.mapper-locations=classpath:mapper/*Mapper.xml
    
    
    sql 
    DROP TABLE IF EXISTS `user`;
    create table `user`(
        `id` int(11) NOT NULL auto_increment,
        `username` varchar(50) default null,
        `password` varchar(50) default null,
        `name` varchar(50) default null,
        primary key (`id`)
    )ENGINE = InnoDB AUTO_INCREMENT=10 DEFAULT  CHARSET=utf8;
    
    
    insert into `user` values ('1','zhangsan','123','张三');
    insert into `user` values ('2','lisi','123','里斯');
    
    

    不连接数据库, 再根据下面修改就好。

    
    
    @Controller
    public class MybatisController {
    
        @RequestMapping(value = "/hello")
        @@ResponseBody
        public String queryUserList(){
            String s = "[{" + "\"name\":\"奥利给\"" + "}]";
            return s;
        }
    }
    

    3. 实体类配置以及mapper配置

    public class User{
        private Integer id;
        private String username;
        private String password;
        private String name;
        
        //get/set自己加    alt+insert
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    import org.apache.ibatis.annotations.Mapper;
    @Mapper
    public interface UserMapper {
        List<User> queryUserList();
    }
    
    <?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.jarvis.springboot_mybatis.mapper.UserMapper">
        <select id="queryUserList" resultType="user">
            select * from user;
        </select>
    
    </mapper>

    4. 创建一个controller目录, 然后在创建一个类,加个@Controller注解

    二、编写react

    1. 复杂的也不会写,就是简单做个数据交互,安装好node和npm后, 利用npm命令 npm install create-react-app 下载create-react-app,然后再create-react-app 项目名创建项目, 具体如何创建自己百度。

    删除掉没用的后

    2. 配置页面跳转

    import React, {Component} from 'react';
    import {BrowserRouter as Router, Route} from 'react-router-dom';
    import Home from './Home';
    import Page1 from './Page1';
    import Page2 from './Page2';
    
    class App extends Component{
      render() {
        return (
            <Router>
              <div>
                  {/*访问其他页面不显示Home*/}
                <Route exact path="/" component={Home}/>
                <Route path="/Page1" component={Page1}/>
                <Route path="/Page2" component={Page2}/>
              </div>
            </Router>
        )
      }
    }
    
    export default App;
    
    
    
    --------------Home
    import React, {Component} from 'react';
    import {Link} from 'react-router-dom';
    
    class Home extends Component{
        render() {
            return (
                <React.Fragment>
                    <div>
                        This is Home!
                    </div>
                    <div>
                        <Link to="/Page1" style={{color:'black'}}>
                            <p>点击跳转到Page1</p>
                        </Link>
                        <Link to="/Page2" style={{color:'black'}}>
                            <p>点击跳转到Page2</p>
                        </Link>
                        <Link to="/Page3" style={{color:'black'}}>
                            <p>点击跳转到Page3</p>
                        </Link>
                    </div>
                </React.Fragment>
            )
        }
    }
    export default Home;
    

    3. 因为react的访问地址是http://127.0.0.1:3000, tomcat访问地址是http://127.0.0.1:8080,端口号不同,所以涉及到跨域问题, 有兴趣可以搜一下。

    所以我采用两种方式进行跨域数据交互

    第一种: fetch方式, 在前端修改请求头, 然后再后端在加上@CrossOrigin注解,可直接加在方法上,加在类上对应所有方法。

    import React, {Component} from 'react'
    
    class Page1 extends Component{
        constructor(props){
            super(props);
            this.state={
                mytext: []
            }
        }
        getData(){
            //修改请求头
            let myHeaders = new Headers({
                'Access-Control-Allow-Origin': '*',
                'Content-Type': 'text/plain'
            });
            fetch('http://127.0.0.1:8080/hello',{
                method:'GET',
                headers: myHeaders,
                mode: 'cors',
                //转或称字符串格式
            }).then(res=>res.json()).then(
                data=>{
                    console.log(data);
                    // eslint-disable-next-line
                    data.map((key)=>{
                        this.setState({
                            mytext: [...this.state.mytext, key]
                        })
                    })
                }
            )
        }
        //React周期函数,防止死循环,在组建被渲染前调用
        componentWillMount(){
            this.getData();
        }
        render() {
            return (
                <React.Fragment>
                    <ul>
                        {
                            this.state.mytext.map((key, index)=>{
                                return <li key={index}>{key.name}</li>
                            })
                        }
                    </ul>
                </React.Fragment>
            )
        }
    }
    export default Page1;
    
    import com.jarvis.springboot_mybatis.Entity.User;
    import com.jarvis.springboot_mybatis.mapper.UserMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    import java.util.List;
    
    @Controller
    @CrossOrigin
    public class MybatisController {
    
        @Autowired
        private UserMapper userMapper;
    
        @RequestMapping(value = "/hello", method = RequestMethod.GET)
        @ResponseBody
        public List<User> hello(){
            List<User> user = userMapper.queryUserList();
            System.out.println(user);
            return user;
        }
    }
    

    第二种方式是XMLHttrRequest方式, 这种方式在前端不用配置,需要在后端设置请求头, 请求的时候需要将localhost改成127.0.0.1,要不然因为不识别会报错, 然后是setResponse需要和Origin保持一致。( F12)

    true和false那是发不发送cookie,自行解决。

    import React, {Component} from 'react'
    
    class Page2 extends Component{
        constructor(props){
            super(props)
            this.state={
                service: [],
            }
        }
        componentDidMount() {
            //ajax方法去服务器取数据,异步true
            const xhr = new XMLHttpRequest()
            xhr.open("GET", "http://127.0.0.1:8080/Page22", true)
            //根据情况选择是否要随get请求发送用于身份认证的信息
            xhr.withCredentials = false
            xhr.send()
    
            xhr.onreadystatechange = () =>{
                /**
                 *   0 UNSENT- open()尚未被调用
                     1 OPENED- send()尚未被调用
                     2 HEADERS_RECEIVED- send()已被调用,并且头和状态可用
                     3 LOADING下载;- responseText的保持部分数据
                     4 - 的操作完成
                 */
                // eslint-disable-next-line
                if(xhr.readyState == XMLHttpRequest.DONE){
                    // eslint-disable-next-line
                    if(xhr.status == 200){
                        let gotService = JSON.parse(xhr.responseText)
                        this.setState({
                            service: gotService
                        })
                    }
                }else {
                    console.log(xhr.readyState + "---加载中")
                }
            }
        }
    
        render() {
            const serviceShows = this.state.service.map((user, index)=>{
                return (
                    <tr key={index}>
                        <td>{user.id}</td>
                        <td>{user.username}</td>
                        <td>{user.name}</td>
                    </tr>
                )
            })
            return (
                <table>
                    <tbody>
                        {serviceShows}
                    </tbody>
                </table>
            )
        }
    }
    export default Page2;
    
    import com.jarvis.springboot_mybatis.Entity.User;
    import com.jarvis.springboot_mybatis.mapper.UserMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    import javax.servlet.http.HttpServletResponse;
    
    import java.util.List;
    
    @Controller
    @CrossOrigin
    public class MybatisController {
    
        @Autowired
        private UserMapper userMapper;
    
        @RequestMapping(value = "/Page22", method = RequestMethod.GET)
        @ResponseBody
        public List<User> helloPage2(HttpServletResponse response){
            List<User> user = userMapper.queryUserList();
            System.out.println(user);
            //response.setHeader("Access-Control-Allow-Credentials","True");
            response.setHeader("Access-Control-Allow-Origin", "http://127.0.0.1:3000");
            response.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
            return user;
        }
    }
    

     

    展开全文
  • 接下来将会介绍在React如何使用axios实现前后端交互。在之前的文章中,我有详细介绍:axios的使用和二次封装,原理基本相同。 2、依赖和配置 安装依赖 cnpm i -S qs axios 复制代码 在新建src下新建api文件夹,...

    1、前言

    1. 之前我们已经介绍了如何:新建一个react项目,并介绍了基本的路由配置、less、以及ui的使用。
    2. 接下来将会介绍在React如何使用axios实现前后端交互。在之前的文章中,我有详细介绍:axios的使用和二次封装,原理基本相同。

    2、依赖和配置

    • 安装依赖
    cnpm i -S qs axios
    复制代码
    import axios from 'axios'
    import qs from 'qs'
    let fetch = axios.create({
        baseURL: "http://localhost:3333", // 这里是本地express启动的服务地址
        timeout: 5000 // request timeout
    })
    fetch.interceptors.request.use(config => {
        if (config.method === 'post' || config.method === 'put' || config.method === 'delete') {
            if (typeof(config.data) !== 'string' && config.headers['Content-Type'] !== 'multipart/form-data') {
                config.data = qs.stringify(config.data)
            }
        }
        return config
    }, error => {
        Promise.reject(error)
    })
    
    fetch.interceptors.response.use(async data => {
        return data
    }, error => {
        if (error.response) {
            if (error.response.status === 500) {
                console.log('服务器错误,请联系管理员处理')
            }
            return Promise.reject(error.response.data)
        } else {
            return Promise.reject(error)
        }
    })
    
    export default fetch
    复制代码
    • 新建index.js文件, 这里我们模拟了两个接口。用于登录检验和获取控制台的菜单数据,跳转到对应的控制台(后续会介绍相关的部分)
    import fetch from './fetch'
    
    // example 获取数据json模拟
    export function apiGetData() {
        return fetch({
            url: '/api/data/menu-list',
            method: 'get'
        })
    }
    
    // 登录校验
    export function apiLogin(params) {
        return fetch({
            url: '/api/login/validate',
            method: 'get',
            params
        })
    }
    复制代码

    3、在页面中使用

    1. 这里我们就以登录页面和控制台页面为例。新建登录页面,配置路由,首页增加点击跳转登录的按钮。
    import { apiLogin } from '@/api';
    复制代码

    2. 这里我们登录页的布局是没有头部底部的,所有路由独立在DefalultLayout之外。 3. 这里在稍微提一下布局,在上一章创建react项目中我们没有引入antd的时候,自己实现了DefalultLayout布局,现在引入antd之后,可以借助Layout布局组件来ConsoleLayout布局。如图中的控制台布局:

    总结

    • 本文主要介绍在react中如何封装并使用axios,这个在vue中axios的按需引用axios的使用和二次封装的原理相同。
    • 简单介绍了借助ui和不借助ui来实现页面布局。
    • 后续会继续更新redux等部分、逐渐的形成一个完成的项目。
    展开全文
  • Springboot+React前后端整合

    Springboot+React前后端整合

    前端执行yarn build,将构建好的文件放入项目的static底下

    前端配好相对路径,避免发生访问不到路径的问题
    在这里插入图片描述

    展开全文
  • springboot+react前后端分离项目中,跨域问题必然存在,解决方案有三种类型: 1、前端解决: 在package.json中添加如下代码: { "name": "myproject1", "version": "0.1.0", "private": true, **"proxy": ...
  • 上周工作中需要将一个react前端项目与spring的后端项目进行联调,但之前从未单独做过这种...前端向后端发请求,则和其他场景下的前后端交互一样,使用ajax或相应方式向对应的url发送请求即可。 而后端向前端的res...
  • 嗯,,前后端分离后,前端怎么调用后端的请求呢? 后端不需要配置,只需要在前端稍微配置就可以。 npm install –save-dev http-proxy-middleware app.js中加入: const proxy = require('...
  • React技术栈为主分享我们在大规模企业应用建设过程中遇到的问题,对前后端分离架构的思考,前后端分离的技术方案,前后端分离过程中的实践经验,前后端分离带来的效果与价值,以及目前存在的问题与未来可能的尝试...
  • 首先是问题的提出:前端如果是react,后端是express,如何进行数据的交互. 1.总体思路 以前接触express的时候前端模板的是ejs,那时候就有些不理解的地方.最为不理解的几个问题是:前端和后端怎么配合?特别是前端特别...
  • Vue 前后端交互

    2019-02-20 16:52:44
    Vue界面在前后端交互的过程中使用的是AJAX的方式来进行的数据交互,我们一般来说使用较多的是Vue-resource 以及 axios 这俩个组件来实现Vue的前后端的交互。 vue-resource 和 axios 的共性及区别 共性: 1....
  • 首先需要对前后端进行大概的认知 前端: 把后端给的数据展示在页面上(列表页面) 把前端的数据传递给后端,让后端存储起来(一般注册会用到) 后端: 当前端需要数据的时候,后端从数据库里面拿到数据给前端 ...
  • 自己一直对数据交互好像都挺执着的。之前有笔记介绍了Ajax 和简单的跨域处理,这篇博客主要还是介绍数据交互,跨域的细节处理就不做记录(配置就行) 前端:React 后端:springboot 一:前端React作简要的介绍 在...
  • react前后端对接(axios)

    2019-10-02 12:48:08
    全局配置 1 安装axios npm ...2 安装cookie npm install react-cookies -S 3 src文件目录下新建文件夹api 4 api 下新建statecode.js //该页面用来返回请求状态 export default { "-1": "系统繁忙", "0": "...
  • 最近想自己搭一个网站,但仅仅会前端还是有点做不到实际情况中的前后端交互,就自己瞎鼓捣了几个工具,来搭一个简单的网站。 工具:  后端处理这种自己做的小网站 Node是最好不过来(其他语言不会。。),选...
  • 问:为什么需要前后端交互? 答:问这个问题之前,你需要对web的标准规范有基本的认识。例如:一个博客网站,你需要提供一个美丽,友好,使用的界面给用户写博客,管理博客(删改),还有展示博客内容,这些页面不...
  • 前后端分离框架前端react,后端springboot跨域问题分析 为啥跨域了 前端react的设置 springboot后端设置 为啥跨域了 由于前后端不在一个端口上,也是属于跨域问题的一种,所以必须解决这个问题. ...
  • 前后端交互优化 传统前后端交互结构如下: 如图所示前后端耦合一起,交互方式http+jsp+js,静态资源和业务代码统一存放同工程,同台服务器部署,服务器接收到浏览器的请求后,进行业务处理返回页面,页面渲染,...
  • 我来到现在这家公司有... 首先是前后端的代码存放在同一个工程目录下,前后端工程师进行开发时,都必须把整个项目导入到开发工具中(像myEclipse和IntelliJ IDEA等),一方面前端在开发之前需要花费大量的时间来部...
  • 前端: 工具:vs code ...import React from 'react'; import ReactDOM from 'react-dom'; import $ from 'jquery'; import './index.css'; //import { Redirect } from 'react-router-dom'; let exa...
1 2 3 4 5 ... 20
收藏数 4,962
精华内容 1,984