Go, 153 128 bytes

Go Johnny, go.

Try it online!

import u"strings"
func(s string)string{t,e:=u.Title(s),", "+s+"\n";return t+e+u.Repeat(t+" Johnny "+s+e,4)+"Johnny B. "+t+"ode"}

05AB1E, 37 bytes

™„, ¹J¹Ð™”ÿºÇ ÿ, ÿ”4.D¹™”ºÇ B. ÿode”»

Try it online!

Explanation

™„, ¹J                                # concatenate title-cased input with ", " and input
     ¹Ð™                              # push input, input, title-cased input
        ”ÿºÇ ÿ, ÿ”                    # push the string "ÿ Johnny ÿ, ÿ" with "ÿ" replaced 
                                      # by title-cased input, input, input
                  4.D                 # push 3 copies of that string
                     ¹™               # push title-cased input
                       ”ºÇ B. ÿode”   # push the string "Johnny B. ÿode" with "ÿ" replaced 
                                      # by title-case input
                                   »  # join the strings by newlines

V, 41 bytes

ä$a, Ùäwa Johnny 5ÄGdwwcWB.W~Aode.ÎvU

Try it online!

The perfect challenge for V!

Pure Bash, 69 76 bytes

M=aaaa;echo -e ${1^}, $1 ${M//a/\\n${1^} Johnny $1, $1}\\nJohnny B. ${1^}ode

Try it online!

Batch, 207 bytes

@set s= %1
@for %%l in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)do @call set s=%%s: %%l=%%l%%
@set j="%s% Johnny %1, %1"
@for %%l in ("%s%, %1" %j% %j% %j% %j% "Johnny B. %s%ode")do @echo %%~l

VIM, 54 49 Keystrokes (saved 1 keystroke from Kritixi Lithos)

yw~hC<Ctrl-R>", <Ctrl-R>0<Enter>Johnny B. <Ctrl-R>"ode<Esc}O<Ctrl-R>", Johnny <Ctrl-R>0, <Ctrl-R>0<Esc>3.         

Start with the word on a line on a file with the cursor at the first character, then this will replace it all with the text Explanation

1. Copy the word into a register, then change the first letter to be capitalized and save that to a register.
2. Write the first line using the registers to fill in the replacements and last lines
3. Write the second line using the registers to fill in the replacements
4. Repeat the middle line 3 times

Pyth - 52 bytes

j", "_ArBQ3V4s[H" Johnny "G", "G;%"Johnny B. %sode"H

Test Suite.

Python, 102 bytes

lambda s:("|, #\n"+"| Johnny #, #\n"*4+"Johnny B. |ode").replace("|",s.title()).replace("#",s.lower())

C, 156 151 bytes

i,a,b;B(char*s){a=*s++;printf("%c%s, %c%s\n",b=a-32,s,a,s);for(;++i%4;)printf("%c%s Johnny %c%s, %c%s\n",b,s,a,s,a,s);printf("Johnny B. %c%sode",b,s);}

Stacked, 64 bytes

:@n tc@N('%N, %n
'!'%N Johnny %n, %n
'!4*'Johnny B. 'N'ode'!)sum

Try it online!

MATLAB/Octave, 133 111 bytes

@(a)regexprep(['1, 2' 10 repmat(['1 32, 2' 10],1,4) '3B. 1ode'],{'1','2','3'},{[a(1)-32 a(2:end)],a,'Johnny '})

It's a start. Can hopefully be reduced further.

Basically it's an anonymous function which takes a string input and then uses regex to create the required output.

@(a)                                                    %Anonymous Function
    regexprep(                                          %Regex Replace
        ['1, 2' 10                                      %First line is: Code, code
            repmat(['1 32, 2' 10],1,4)                  %Then four lines of: Code Johnny code, code 
                               '3B. 1ode'],             %Final line: Johnny B. Codeode
         {'1','2','3'},                                 %1,2,3 are our replace strings in the lines above
         {[a(1)-32 a(2:end)],a,'Johnny '}               %We replace with '(I)nput', 'input' and 'Johnny ' respectively.
    )

An example:

@(a)regexprep(['1, 2' 10 repmat(['1 32, 2' 10],1,4) '3B. 1ode'],{'1','2','3'},{[a(1)-32 a(2:end)],a,'Johnny '});
ans('hi')
ans =

Hi, hi
Hi Johnny hi, hi
Hi Johnny hi, hi
Hi Johnny hi, hi
Hi Johnny hi, hi
Johnny B. Hiode

You can sort of Try it online!. The code doesn't quite work with Octave as all the upper case letters become ${upper($0)}, whereas in MATLAB this is converted to the actual upper case letter.

Given the input is guaranteed to only be a-z (lowercase alphabet), I can save 22 bytes by using a simple subtraction of 32 to convert the first letter in the string to capital, rather than using regex with the upper() function.

As a result, the code now works with Octave as well, so you can now Try it online!

Retina, 65 bytes

Byte count assumes ISO 8859-1 encoding.

^
$', 
:T01`l`L
:`,
 Johnny$',
:`$
¶$`
(\S+) (\S+ ).+$
$2B. $1ode

Try it online!

Jelly, 41 bytes

5“ Johnny “, “¶”ẋj¹Ḋṙ7ỴŒu1¦€Y“B. ”⁸Œt“ode

Try it online!

JavaScript (ES6), 104 bytes

(i,u=i[0].toUpperCase()+i.slice(1))=>u+`, ${i}
${u} Johnny ${i}`.repeat(4)+`, ${i}
Johnny B. ${u}ode`;

How it works:

• It's an anonymous function that takes the input as the parameter i

• Defines a variable u as the input i with the first letter capitalized (Note that this assumes input is nonempty, which is OK)

• Just directly construct the string to be returned from those two variables.

• Repeating the string "go, \nGo Johnny go" four times instead of repeating "Go Johnny go, go" saves one byte.

Test snippet

let f = (i,u=i[0].toUpperCase()+i.slice(1))=>u+`, ${i}
${u} Johnny ${i}`.repeat(4)+`, ${i}
Johnny B. ${u}ode`;

<input id=I type="text" size=70 value="code"><button onclick="console.log(f(I.value))">Run</button>

Python 3, 86 bytes

lambda x:("{0}, {1}\n"+4*"{0} Johnny {1}, {1}\n"+"Johnny B. {0}ode").format(x.title(),x)

A simple format string, with positional arguments.

PHP, 88 Bytes

<?=$u=ucfirst($l=$argv[1]),", $l\n",$r="$u Johnny $l, $l\n","$r$r{$r}Johnny B. {$u}ode";

CJam, 50 bytes

r:L(eu\+:M',SLN[MS"Johnny ":OL',SLN]4*O"B. "M"ode"

Try it online!

Explanation:

r:L(eu\+:M',SLN[MS"Johnny ":OL',SLN]4*O"B. "M"ode" e# Accepts an input token.
r:L                                                e# Gets input token and stores it in L.
   (eu\+:M                                         e# Converts token to uppercase-first and stores it in M.
          ',S                                      e# Appears as ", ".
             L                                     e# Input token.
              N                                    e# Newline.
               [                                   e# Opens array.
                M                                  e# Modified token.
                 S                                 e# Space.
                  "Johnny ":O                      e# Pushes "Johnny " and stores it in O.
                             L                     e# Input token.
                              ',SLN                e# The same {',SLN} as before.
                                   ]4*             e# Closes array and repeats it 4 times.
                                      O            e# "Johnny ".
                                       "B. "       e# "B. ".
                                            M      e# Modified token.
                                             "ode" e# "ode".

Pyke, 43 bytes

l5j", "Qs3
Qld"Johnny "iQs3:D4i"B. ode"+Tj:

Try it online!

Constructs and prints the first line then inserts Johnny go before the comma and duplicates that 4 times. Finally constructs the last part.

Java, 258 bytes

enum j{;public static void main(String[]a){char[]b=a[0].toCharArray();b[0]=(char)(b[0]^32);System.out.printf("%1$s, %2$s\n%1$s %3$s %2$s, %2$s\n%1$s %3$s %2$s, %2$s\n%1$s %3$s %2$s, %2$s\n%1$s %3$s %2$s, %2$s\n%3$s B. %1$sode",new String(b),a[0],"Johnny");}}

Longest part of it is the format for printf. There are problems with input different than string from a to z(yes I know I don't need to support anything else).

Ungolfed with comments:

enum j {
    ;

    public static void main(String[] a) {
        char[] b = a[0].toCharArray();              // Copy of the input string
        b[0] = (char) (b[0]^32);                    // First character of copy to uppercase
        System.out.printf(
                "%1$s, %2$s\n%1$s %3$s %2$s, %2$s\n%1$s %3$s %2$s, %2$s\n%1$s %3$s %2$s, %2$s\n%1$s %3$s %2$s, %2$s\n%3$s B. %1$sode", // Format string
                new String(b),  // Capitalized string
                a[0],           // Original input string
                "Johnny");      // "Johnny"
    }
}

Ruby, 89 88 86 bytes

My first golf submission :

->(x){"^, *\n#{"^ Johnny *, *\n"*4}Johnny B. ^ode".gsub('^',x.capitalize).gsub('*',x)}

Kotlin, 112 Bytes

fun g(s:String):String{val u=s.capitalize();return "$u, $s\n${"$u Johnny $s, $s\n".repeat(4)}Johnny B. ${u}ode"}

Ungolfed:

fun g(s: String): String {
    val u = s.capitalize()
    return "$u, $s\n${"$u Johnny $s, $s\n".repeat(4)}Johnny B. ${u}ode"
}

VBA, 138 Bytes

Subroutine that takes variant input b of assumed type string, and outputs by printing the the VBE immediates window

Sub a(b)
n=vbCr
c=b
Mid(c,1,1)=UCase(b)
s=c &", " &b
For i=1To 4
s=s &n &c &" Johnny " &b &", " &b
Next
Debug.?s &n &"Johnny B. " &c &"ode"
End Sub

Example Case

a "an"          ''  <- subroutine call
An, an          ''  <- output
An Johnny an, an
An Johnny an, an
An Johnny an, an
An Johnny an, an
Johnny B. Anode

Python, 258 bytes

from jinja2 import Template
def f(go):
    t = Template("""{{ Go }}, {{ go }}
{{ Go }} Johnny {{ go }}, {{ go }}
{{ Go }} Johnny {{ go }}, {{ go }}
{{ Go }} Johnny {{ go }}, {{ go }}
{{ Go }} Johnny {{ go }}, {{ go }}
Johnny B. {{ Go }}ode""")
    return t.render(Go=go.title(), go=go)